@dimina-kit/devtools 0.4.0-dev.20260625063832 → 0.4.0-dev.20260630033804

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

@@ -653,12 +653,24 @@ export function createViewManager(ctx) {
         // interceptor re-emits an encoded sentinel via
         // `InspectorFrontendHost.openInNewTab` → Electron `devtools-open-url`. (The
         // legacy `setOpenResourceHandler` hook this used to rely on is gone in
-        // current Chromium, so the script keeps it only as a fallback.) Best-effort:
-        // the script is fully try/catch-wrapped so a missing API never throws.
-        const sourceContext = projectSourceContextFromServiceHostUrl(serviceWc.getURL(), ctx.workspace?.getProjectPath?.());
-        if (!sourceContext)
+        // current Chromium, so the script keeps it only as a fallback.)
+        //
+        // Destroy-race chokepoint: this runs from a deferred `dom-ready` callback
+        // (see wireOpenInEditor), by which time the inspected service-host wc may
+        // already be torn down (pool swap / project close / relaunch). Reading
+        // `serviceWc.getURL()` on a destroyed wc throws "Object has been destroyed"
+        // synchronously, which would escape the event listener. Guard both wc and
+        // wrap the body so a teardown mid-call degrades silently (mirrors
+        // customizeDevtoolsTabs).
+        if (serviceWc.isDestroyed() || devtoolsWc.isDestroyed())
             return;
-        devtoolsWc.executeJavaScript(buildDevtoolsProjectSourceLinksScript(sourceContext)).catch(() => { });
+        try {
+            const sourceContext = projectSourceContextFromServiceHostUrl(serviceWc.getURL(), ctx.workspace?.getProjectPath?.());
+            if (!sourceContext)
+                return;
+            devtoolsWc.executeJavaScript(buildDevtoolsProjectSourceLinksScript(sourceContext)).catch(() => { });
+        }
+        catch { /* wc torn down mid-call — degrade silently */ }
     }
     // ── DevTools tab customization: keep only Elements/Console/Network ──────────
     // Inject into the same DevTools front-end host wc that the console/network
@@ -877,13 +889,22 @@ export function createViewManager(ctx) {
                 stopElementsForward?.();
             }
             catch { /* prior disposer already gone */ }
-            stopElementsForward = installElementsForward({ devtoolsWc, bridge: ctx.bridge, connections: ctx.connections });
+            // Capture THIS instance's disposer in the destroy handler — NOT the mutable
+            // `stopElementsForward`. A respawn creates a new simulatorView whose old
+            // devtools host wc is destroyed AFTER the new instance is already installed;
+            // a handler closing over `stopElementsForward` would then dispose the CURRENT
+            // instance (its reconcile loop never gets to install the hook, so Elements
+            // falls back to the natively-inspected service host). Stop only this wc's own
+            // forward, and clear the module pointer only while it still points here.
+            const thisForward = installElementsForward({ devtoolsWc, bridge: ctx.bridge, connections: ctx.connections });
+            stopElementsForward = thisForward;
             devtoolsWc.once('destroyed', () => {
                 try {
-                    stopElementsForward?.();
+                    thisForward();
                 }
                 catch { /* already stopped */ }
-                stopElementsForward = null;
+                if (stopElementsForward === thisForward)
+                    stopElementsForward = null;
             });
         }
         devtoolsWc.once('dom-ready', () => {
@@ -934,6 +955,40 @@ export function createViewManager(ctx) {
             nativeCustomApiBridgeHandler = null;
         }
     }
+    /**
+     * The single teardown path for the live native-host simulator WCV, shared by
+     * relaunch (attachNativeSimulator replacing the view) and project close
+     * (detachSimulator). Detaches the view from the window, then synchronously
+     * clears its bridge sessions (render guests + service host + mappings) BEFORE
+     * the WCV's own async close(), so the next project never re-resolves,
+     * re-renders, or screenshots the outgoing guest. The sync prefix clears the
+     * maps immediately; the async tail (pool / resource-server release) is observed
+     * so a rejection is logged rather than swallowed. The simulatorWc 'destroyed'
+     * hook in bridge-router stays as an idempotent fallback. No-op when no view is
+     * live; idempotent (disposeSessionsForSimulator early-returns once a session is
+     * gone), so the eager teardown here and the 'destroyed' fallback never
+     * double-dispose. `label` only tags the diagnostic on the async-tail failure.
+     */
+    function tearDownNativeSimulatorView(label) {
+        if (!nativeSimulatorView)
+            return;
+        if (nativeSimulatorViewAdded && !ctx.windows.mainWindow.isDestroyed()) {
+            try {
+                ctx.windows.mainWindow.contentView.removeChildView(nativeSimulatorView);
+            }
+            catch { /* already removed */ }
+        }
+        try {
+            if (!nativeSimulatorView.webContents.isDestroyed()) {
+                ctx.bridge?.disposeSessionsForSimulator?.(nativeSimulatorView.webContents.id)
+                    ?.catch((err) => console.warn(`[view-manager] dispose sessions (${label}) failed:`, err));
+                nativeSimulatorView.webContents.close();
+            }
+        }
+        catch { /* ignore */ }
+        nativeSimulatorView = null;
+        nativeSimulatorViewAdded = false;
+    }
     /**
      * NATIVE-HOST ONLY. The native simulator is a top-level WebContentsView with
      * NO embedder renderer, so the simulator-side `__diminaCustomApis` bridge
@@ -996,23 +1051,12 @@ export function createViewManager(ctx) {
         // that generation cancelled, so this cannot schedule a stale capture.
         settleNativeSimulatorReady?.();
         settleNativeSimulatorReady = null;
-        // Tear down any previous native simulator view (relaunch / re-open).
+        // Tear down any previous native simulator view (relaunch / re-open) through
+        // the shared single teardown path. detachNativeCustomApiBridge stays here
+        // (the bridge dispatcher is re-installed per attach below).
         if (nativeSimulatorView) {
             detachNativeCustomApiBridge();
-            if (nativeSimulatorViewAdded) {
-                try {
-                    ctx.windows.mainWindow.contentView.removeChildView(nativeSimulatorView);
-                }
-                catch { /* already removed */ }
-                nativeSimulatorViewAdded = false;
-            }
-            try {
-                if (!nativeSimulatorView.webContents.isDestroyed()) {
-                    nativeSimulatorView.webContents.close();
-                }
-            }
-            catch { /* ignore */ }
-            nativeSimulatorView = null;
+            tearDownNativeSimulatorView('relaunch');
         }
         nativeSimulatorProjectPath = null;
         const ready = new Promise((resolve) => {
@@ -1025,7 +1069,11 @@ export function createViewManager(ctx) {
         // (protocol handlers + CORS/referer policy) before any project content loads
         // on it — idempotent per partition.
         const route = parseRoute(simulatorUrl);
-        const partition = miniappPartition(route?.appId);
+        // Include the project path so two projects that declare the same appId at
+        // different paths get isolated partitions. The service-host window for THIS
+        // project derives its partition from the same (appId, projectPath) pair so
+        // render guests + service host still share one session.
+        const partition = miniappPartition(route?.appId, ctx.workspace?.getProjectPath());
         configureMiniappSession(partition);
         // The simulator preload is a CJS bundle; webPreferences.preload obeys the
         // `.js` + "type":"module" ESM rule (require would be undefined), so hand the
@@ -1221,23 +1269,10 @@ export function createViewManager(ctx) {
         // back to the console.
         ctx.networkForward?.detachSimulator();
         ctx.networkForward?.setDevtoolsHost(null);
-        // Native-host simulator content view (no-op in the default path).
-        if (nativeSimulatorView) {
-            if (nativeSimulatorViewAdded && !ctx.windows.mainWindow.isDestroyed()) {
-                try {
-                    ctx.windows.mainWindow.contentView.removeChildView(nativeSimulatorView);
-                }
-                catch { /* already removed */ }
-            }
-            try {
-                if (!nativeSimulatorView.webContents.isDestroyed()) {
-                    nativeSimulatorView.webContents.close();
-                }
-            }
-            catch { /* ignore */ }
-            nativeSimulatorView = null;
-            nativeSimulatorViewAdded = false;
-        }
+        // Native-host simulator content view (no-op in the default path) — same
+        // single teardown path as relaunch. detachNativeCustomApiBridge was already
+        // called above.
+        tearDownNativeSimulatorView('close');
         hidePopover();
         // Drop the settings view too — the previous detachAllViews() did.
         destroyViewInternal(settingsView);

package/dist/main/services/workbench-coi-server.d.ts

@@ -14,6 +14,13 @@ export interface WorkbenchCoiServerOptions {
      * manifest the workbench reads at boot. Omit for none.
      */
     extensionsDir?: string;
+    /**
+     * Reads the host's custom file types (e.g. `.qdml`/`.qdss`/`.qds`), served at
+     * `/__filetypes` so the workbench maps them to `files.associations`. Read
+     * per-request so a project switch takes effect on the next editor boot. Omit
+     * for none (built-in `wx*` associations only).
+     */
+    getFileTypes?: () => unknown;
 }
 export declare function startWorkbenchCoiServer(options: WorkbenchCoiServerOptions): Promise<WorkbenchCoiServer>;
 //# sourceMappingURL=workbench-coi-server.d.ts.map

package/dist/main/services/workbench-coi-server.js

@@ -317,6 +317,12 @@ export async function startWorkbenchCoiServer(options) {
             });
             return;
         }
+        // Host custom file types for the editor's `files.associations`. Read-only;
+        // empty object when the host configured none.
+        if (url.pathname === '/__filetypes') {
+            jsonRes(res, 200, options.getFileTypes?.() ?? {});
+            return;
+        }
         // Host-contributed web extensions: manifest + static files (same-origin so
         // they satisfy the workbench's COEP require-corp).
         if (url.pathname.startsWith('/__contrib/')) {

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

@@ -1,5 +1,5 @@
 import type { BrowserWindow } from 'electron';
-import type { CompilationAdapter, WorkbenchConfig } from '../../shared/types.js';
+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 { NetworkForwarder } from './network-forward/index.js';
@@ -27,6 +27,8 @@ export interface WorkbenchContext {
     rendererDir: string;
     /** Custom API namespace names (e.g. ['qd']) passed to the simulator */
     apiNamespaces: string[];
+    /** Custom file types (e.g. .qdml/.qdss/.qds) forwarded to compilation and served to the editor via the COI `/__filetypes` endpoint. */
+    fileTypes: CustomFileTypes;
     /** Branding name shown in title bar and getBranding IPC */
     appName: string;
     /** Host-injected provider for branding info (overrides default appName) */
@@ -178,7 +180,7 @@ export interface WorkbenchContext {
  *  - `projectsProvider` / `projectTemplates` / `customCreateProjectDialog` use
  *    the main-process types, not the structural mirrors in `shared/types`.
  */
-export interface CreateContextOptions extends Pick<WorkbenchConfig, 'adapter' | 'apiNamespaces' | 'appName'> {
+export interface CreateContextOptions extends Pick<WorkbenchConfig, 'adapter' | 'apiNamespaces' | 'appName' | 'fileTypes'> {
     mainWindow: BrowserWindow;
     preloadPath: string;
     rendererDir: string;

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

@@ -16,6 +16,7 @@ export function createWorkbenchContext(opts) {
         preloadPath: opts.preloadPath,
         rendererDir: opts.rendererDir,
         apiNamespaces: opts.apiNamespaces ?? [],
+        fileTypes: opts.fileTypes ?? {},
         appName: opts.appName ?? 'Dimina DevTools',
         brandingProvider: opts.brandingProvider,
     };

package/dist/main/services/workspace/op-lock.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Lifecycle serialization primitive for the workspace's openProject/closeProject.
+ *
+ * Two parts working together (see workspace-service for the full rationale):
+ *  - A FIFO async lock so the teardown/commit critical sections of open and
+ *    close never interleave. The unbounded compile runs between an open's two
+ *    sections WITHOUT holding the lock, so a queued close is never blocked by a
+ *    slow/hung compile (close is bounded by disposeSession's own timeout).
+ *  - A latest-wins request token. `nextSeq()` is claimed at the START of every
+ *    op (before any await) so it encodes REQUEST order, not hook/compile
+ *    completion order. `takeOwnership` promotes a seq (highest wins); a section
+ *    that finds `!isOwner(mySeq)` was superseded while it released the lock and
+ *    must abort instead of clobbering the newer request's runtime.
+ */
+export interface OpLock {
+    /** Claim a monotonic request seq. Call once at op entry, before any await. */
+    nextSeq(): number;
+    /** Promote a seq to the runtime owner. Only the highest seq ever wins. */
+    takeOwnership(seq: number): void;
+    /** Whether `seq` is still the current owner (false ⇒ superseded). */
+    isOwner(seq: number): boolean;
+    /** Acquire the FIFO lock; await the result, then call it to release. */
+    acquire(): Promise<() => void>;
+}
+export declare function createOpLock(): OpLock;
+//# sourceMappingURL=op-lock.d.ts.map

package/dist/main/services/workspace/op-lock.js

@@ -0,0 +1,23 @@
+export function createOpLock() {
+    let chain = Promise.resolve();
+    let requestSeq = 0;
+    let ownerSeq = 0;
+    return {
+        nextSeq: () => ++requestSeq,
+        takeOwnership: (seq) => {
+            if (seq > ownerSeq)
+                ownerSeq = seq;
+        },
+        isOwner: (seq) => seq === ownerSeq,
+        acquire: () => {
+            let release;
+            const next = new Promise((resolve) => {
+                release = resolve;
+            });
+            const prior = chain;
+            chain = prior.then(() => next);
+            return prior.then(() => release);
+        },
+    };
+}
+//# sourceMappingURL=op-lock.js.map

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

@@ -43,6 +43,13 @@ export interface WorkspaceService {
      */
     getLastClosedProjectPath(): string;
     hasActiveSession(): boolean;
+    /**
+     * True only while `closeProject` is tearing down. Bridge active-content
+     * resolution consults this to avoid resolving the dying session's guest during
+     * the close's session.close() await (when currentSession is already null but
+     * the bridge app session still exists).
+     */
+    isClosing(): boolean;
     captureThumbnail(projectPath: string): Promise<string | null>;
     getThumbnail(projectPath: string): Promise<string | null>;
     getProjectPages(projectPath: string): ProjectPages;