@dimina-kit/devtools 0.4.0-dev.20260702182435 → 0.4.0-dev.20260703101348

package/dist/main/services/service-console/console-api.js

@@ -34,35 +34,25 @@ export function mapConsoleApiType(type) {
 }
 const BIGINT_LITERAL = /^-?\d+n$/;
 /**
- * A single RemoteObject → a JSON-serializable value WITHOUT a CDP round-trip
- * (shallow). Objects that need their full contents are flagged by
- * {@link needsDeepFetch} and deep-serialized by the caller; this is the
- * inline/best-effort fallback.
+ * A CDP `unserializableValue` string (specials that can't ride in `value`,
+ * e.g. `Infinity`/`NaN`/bigint literals) → the JS value it denotes. Unknown
+ * literals pass through as-is (e.g. a bigint literal stays a string).
  */
-export function remoteObjectToValue(ro) {
-    if (!ro)
-        return ro;
-    // 1. An inlined value (CDP includes `value` for JSON-serializable primitives
-    //    and small arrays). Use `in` so falsy values (0, '', false) and an
-    //    explicit `null` are honoured rather than falling through.
-    if ('value' in ro)
-        return ro.value;
-    // 2. Specials that can't ride in `value`.
-    if (typeof ro.unserializableValue === 'string') {
-        const u = ro.unserializableValue;
-        if (u === 'Infinity')
-            return Infinity;
-        if (u === '-Infinity')
-            return -Infinity;
-        if (u === 'NaN')
-            return NaN;
-        if (u === '-0')
-            return -0;
-        if (BIGINT_LITERAL.test(u))
-            return u;
+function unserializableToValue(u) {
+    if (u === 'Infinity')
+        return Infinity;
+    if (u === '-Infinity')
+        return -Infinity;
+    if (u === 'NaN')
+        return NaN;
+    if (u === '-0')
+        return -0;
+    if (BIGINT_LITERAL.test(u))
         return u;
-    }
-    // 3. Fall back by type.
+    return u;
+}
+/** Fallback serialization by `RemoteObject.type` when neither `value` nor `unserializableValue` is present. */
+function typeFallbackToValue(ro) {
     switch (ro.type) {
         case 'undefined':
             return undefined;
@@ -78,6 +68,25 @@ export function remoteObjectToValue(ro) {
             return ro.description ?? '[Unknown]';
     }
 }
+/**
+ * A single RemoteObject → a JSON-serializable value WITHOUT a CDP round-trip
+ * (shallow). Objects that need their full contents are flagged by
+ * {@link needsDeepFetch} and deep-serialized by the caller; this is the
+ * inline/best-effort fallback.
+ */
+export function remoteObjectToValue(ro) {
+    if (!ro)
+        return ro;
+    // An inlined value (CDP includes `value` for JSON-serializable primitives
+    // and small arrays). Use `in` so falsy values (0, '', false) and an
+    // explicit `null` are honoured rather than falling through.
+    if ('value' in ro)
+        return ro.value;
+    if (typeof ro.unserializableValue === 'string') {
+        return unserializableToValue(ro.unserializableValue);
+    }
+    return typeFallbackToValue(ro);
+}
 /**
  * Whether this RemoteObject must be deep-fetched via `Runtime.callFunctionOn`
  * (returnByValue) to be fully serialized — i.e. a real object/array referenced

package/dist/main/services/simulator-temp-files/disk.js

@@ -62,49 +62,63 @@ const EXT_MIME = {
     '.pdf': 'application/pdf',
     '.zip': 'application/zip',
 };
-function sniffMime(head) {
-    if (head.length >= 8
+function isPng(head) {
+    return head.length >= 8
         && head[0] === 0x89 && head[1] === 0x50 && head[2] === 0x4e && head[3] === 0x47
-        && head[4] === 0x0d && head[5] === 0x0a && head[6] === 0x1a && head[7] === 0x0a) {
-        return 'image/png';
-    }
-    if (head.length >= 3 && head[0] === 0xff && head[1] === 0xd8 && head[2] === 0xff) {
-        return 'image/jpeg';
-    }
-    if (head.length >= 6
+        && head[4] === 0x0d && head[5] === 0x0a && head[6] === 0x1a && head[7] === 0x0a;
+}
+function isJpeg(head) {
+    return head.length >= 3 && head[0] === 0xff && head[1] === 0xd8 && head[2] === 0xff;
+}
+function isGif(head) {
+    return head.length >= 6
         && head[0] === 0x47 && head[1] === 0x49 && head[2] === 0x46
-        && head[3] === 0x38 && (head[4] === 0x37 || head[4] === 0x39) && head[5] === 0x61) {
-        return 'image/gif';
-    }
-    if (head.length >= 12
+        && head[3] === 0x38 && (head[4] === 0x37 || head[4] === 0x39) && head[5] === 0x61;
+}
+function isWebp(head) {
+    return head.length >= 12
         && head[0] === 0x52 && head[1] === 0x49 && head[2] === 0x46 && head[3] === 0x46
-        && head[8] === 0x57 && head[9] === 0x45 && head[10] === 0x42 && head[11] === 0x50) {
-        return 'image/webp';
-    }
-    if (head.length >= 12
-        && head[4] === 0x66 && head[5] === 0x74 && head[6] === 0x79 && head[7] === 0x70) {
-        // MP4 ftyp box: brand bytes vary, treat all as video/mp4 for now.
-        return 'video/mp4';
-    }
-    if (head.length >= 4
-        && head[0] === 0x25 && head[1] === 0x50 && head[2] === 0x44 && head[3] === 0x46) {
-        return 'application/pdf';
-    }
-    if (head.length >= 2 && head[0] === 0x42 && head[1] === 0x4d) {
-        return 'image/bmp';
-    }
-    if (head.length >= 4
-        && head[0] === 0x50 && head[1] === 0x4b && head[2] === 0x03 && head[3] === 0x04) {
-        return 'application/zip';
-    }
-    if (head.length >= 3 && head[0] === 0x49 && head[1] === 0x44 && head[2] === 0x33) {
-        // ID3-tagged MP3.
-        return 'audio/mpeg';
-    }
-    if (head.length >= 4 && head[0] === 0x4f && head[1] === 0x67 && head[2] === 0x67 && head[3] === 0x53) {
-        return 'audio/ogg';
-    }
-    return null;
+        && head[8] === 0x57 && head[9] === 0x45 && head[10] === 0x42 && head[11] === 0x50;
+}
+/** MP4 ftyp box: brand bytes vary, treat all as video/mp4 for now. */
+function isMp4(head) {
+    return head.length >= 12
+        && head[4] === 0x66 && head[5] === 0x74 && head[6] === 0x79 && head[7] === 0x70;
+}
+function isPdf(head) {
+    return head.length >= 4
+        && head[0] === 0x25 && head[1] === 0x50 && head[2] === 0x44 && head[3] === 0x46;
+}
+function isBmp(head) {
+    return head.length >= 2 && head[0] === 0x42 && head[1] === 0x4d;
+}
+function isZip(head) {
+    return head.length >= 4
+        && head[0] === 0x50 && head[1] === 0x4b && head[2] === 0x03 && head[3] === 0x04;
+}
+/** ID3-tagged MP3. */
+function isId3Mp3(head) {
+    return head.length >= 3 && head[0] === 0x49 && head[1] === 0x44 && head[2] === 0x33;
+}
+function isOgg(head) {
+    return head.length >= 4 && head[0] === 0x4f && head[1] === 0x67 && head[2] === 0x67 && head[3] === 0x53;
+}
+/** Magic-byte sniffers in priority order — first match wins. */
+const MAGIC_SNIFFERS = [
+    { mime: 'image/png', match: isPng },
+    { mime: 'image/jpeg', match: isJpeg },
+    { mime: 'image/gif', match: isGif },
+    { mime: 'image/webp', match: isWebp },
+    { mime: 'video/mp4', match: isMp4 },
+    { mime: 'application/pdf', match: isPdf },
+    { mime: 'image/bmp', match: isBmp },
+    { mime: 'application/zip', match: isZip },
+    { mime: 'audio/mpeg', match: isId3Mp3 },
+    { mime: 'audio/ogg', match: isOgg },
+];
+function sniffMime(head) {
+    const hit = MAGIC_SNIFFERS.find((sniffer) => sniffer.match(head));
+    return hit ? hit.mime : null;
 }
 function extMime(realPath) {
     const ext = path.extname(realPath).toLowerCase();
@@ -126,6 +140,54 @@ function etagOf(mtimeMs, size) {
     return `W/"${Math.floor(mtimeMs)}-${size}"`;
 }
 // -- read -------------------------------------------------------------------
+/** Validate `range` against `totalSize` and resolve it to a byte slice, or throws. */
+function resolveRange(range, totalSize) {
+    const { start, end } = range;
+    if (!Number.isFinite(start) || !Number.isFinite(end)) {
+        throw new RangeError(`invalid range: ${start}-${end}`);
+    }
+    if (start < 0)
+        throw new RangeError(`range start out of bounds: ${start}`);
+    if (start > end)
+        throw new RangeError(`range start > end: ${start} > ${end}`);
+    if (start >= totalSize) {
+        throw new RangeError(`range start beyond file size: ${start} >= ${totalSize}`);
+    }
+    const clampedEnd = Math.min(end, totalSize - 1);
+    return { sliceStart: start, sliceLen: clampedEnd - start + 1 };
+}
+/**
+ * Read at most the first 12 bytes for magic sniffing, regardless of whether
+ * the caller asked for a range. The head bytes from position 0 are needed to
+ * label Content-Type correctly even on a tail Range request.
+ */
+async function readHeadBytes(handle, totalSize) {
+    const head = Buffer.alloc(Math.min(12, totalSize));
+    if (head.length > 0) {
+        await handle.read(head, 0, head.length, 0);
+    }
+    return head;
+}
+/** Full-file body, re-using `head` (already read) instead of a second read for the leading bytes. */
+async function readFullBody(handle, head, totalSize) {
+    const bytes = Buffer.alloc(totalSize);
+    if (totalSize === 0)
+        return bytes;
+    if (totalSize <= head.length) {
+        head.copy(bytes, 0, 0, totalSize);
+        return bytes;
+    }
+    head.copy(bytes, 0, 0, head.length);
+    await handle.read(bytes, head.length, totalSize - head.length, head.length);
+    return bytes;
+}
+async function readRangeBody(handle, sliceStart, sliceLen) {
+    const bytes = Buffer.alloc(sliceLen);
+    if (sliceLen > 0) {
+        await handle.read(bytes, 0, sliceLen, sliceStart);
+    }
+    return bytes;
+}
 export async function readDiskFile(realPath, opts) {
     const handle = await fs.open(realPath, 'r');
     try {
@@ -133,52 +195,13 @@ export async function readDiskFile(realPath, opts) {
         const totalSize = st.size;
         const mtimeMs = st.mtimeMs;
         const range = opts?.range;
-        let sliceStart = 0;
-        let sliceLen = totalSize;
-        if (range) {
-            const { start, end } = range;
-            if (!Number.isFinite(start) || !Number.isFinite(end)) {
-                throw new RangeError(`invalid range: ${start}-${end}`);
-            }
-            if (start < 0)
-                throw new RangeError(`range start out of bounds: ${start}`);
-            if (start > end)
-                throw new RangeError(`range start > end: ${start} > ${end}`);
-            if (start >= totalSize) {
-                throw new RangeError(`range start beyond file size: ${start} >= ${totalSize}`);
-            }
-            const clampedEnd = Math.min(end, totalSize - 1);
-            sliceStart = start;
-            sliceLen = clampedEnd - start + 1;
-        }
-        // Read at most the first 12 bytes for magic sniffing, regardless of
-        // whether the caller asked for a range. We need the head bytes from
-        // position 0 to label Content-Type correctly even on a tail Range
-        // request. For full reads the head is part of the body so we re-use
-        // it without a second read.
-        const head = Buffer.alloc(Math.min(12, totalSize));
-        if (head.length > 0) {
-            await handle.read(head, 0, head.length, 0);
-        }
-        let bytes;
-        if (!range) {
-            bytes = Buffer.alloc(totalSize);
-            if (totalSize > 0) {
-                if (totalSize <= head.length) {
-                    head.copy(bytes, 0, 0, totalSize);
-                }
-                else {
-                    head.copy(bytes, 0, 0, head.length);
-                    await handle.read(bytes, head.length, totalSize - head.length, head.length);
-                }
-            }
-        }
-        else {
-            bytes = Buffer.alloc(sliceLen);
-            if (sliceLen > 0) {
-                await handle.read(bytes, 0, sliceLen, sliceStart);
-            }
-        }
+        const { sliceStart, sliceLen } = range
+            ? resolveRange(range, totalSize)
+            : { sliceStart: 0, sliceLen: totalSize };
+        const head = await readHeadBytes(handle, totalSize);
+        const bytes = range
+            ? await readRangeBody(handle, sliceStart, sliceLen)
+            : await readFullBody(handle, head, totalSize);
         return {
             bytes,
             mime: detectMime(realPath, head),

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

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

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

@@ -188,6 +188,59 @@ function fsErrorStatus(e) {
         return 404;
     return 500;
 }
+async function fsStat(ctx) {
+    const st = await statWithin(ctx.projectRoot, ctx.rel);
+    jsonRes(ctx.res, 200, { type: st.isDirectory() ? 2 : 1, size: st.size, ctime: st.ctimeMs, mtime: st.mtimeMs });
+}
+async function fsReaddir(ctx) {
+    const entries = await readdirWithin(ctx.projectRoot, ctx.rel);
+    jsonRes(ctx.res, 200, entries.map((e) => [e.name, e.isDirectory() ? 2 : 1]));
+}
+async function fsRead(ctx) {
+    const buf = await readFileBufferWithin(ctx.projectRoot, ctx.rel);
+    ctx.res.writeHead(200, { 'Content-Type': 'application/octet-stream', 'Content-Length': buf.length });
+    ctx.res.end(buf);
+}
+async function fsWrite(ctx) {
+    let buf;
+    try {
+        buf = await readBody(ctx.req);
+    }
+    catch (e) {
+        if (e instanceof BodyTooLargeError)
+            return jsonRes(ctx.res, 413, { error: e.message });
+        throw e;
+    }
+    await writeFileWithin(ctx.projectRoot, ctx.rel, buf);
+    ctx.res.writeHead(204);
+    ctx.res.end();
+}
+async function fsMkdir(ctx) {
+    await mkdirWithin(ctx.projectRoot, ctx.rel);
+    ctx.res.writeHead(204);
+    ctx.res.end();
+}
+async function fsDelete(ctx) {
+    await deleteWithin(ctx.projectRoot, ctx.rel);
+    ctx.res.writeHead(204);
+    ctx.res.end();
+}
+async function fsRename(ctx) {
+    const toRel = (ctx.url.searchParams.get('to') ?? '').replace(/^\/+/, '');
+    await renameWithin(ctx.projectRoot, ctx.rel, toRel);
+    ctx.res.writeHead(204);
+    ctx.res.end();
+}
+/** One handler per supported `/__fs/<action>` — keyed lookup replaces an if-chain. */
+const FS_ACTIONS = {
+    stat: fsStat,
+    readdir: fsReaddir,
+    read: fsRead,
+    write: fsWrite,
+    mkdir: fsMkdir,
+    delete: fsDelete,
+    rename: fsRename,
+};
 /**
  * `/__fs/<action>?p=<rel>` bridge onto the live active project root.
  * `p`/`to` are POSIX paths relative to the project root, resolved through the
@@ -205,54 +258,14 @@ async function handleFsRequest(req, res, projectRoot, url) {
             return jsonRes(res, rejectStatus, { error: 'mutating fs action requires a non-GET same-origin request' });
         }
     }
-    try {
-        if (action === 'stat') {
-            const st = await statWithin(projectRoot, rel);
-            return jsonRes(res, 200, { type: st.isDirectory() ? 2 : 1, size: st.size, ctime: st.ctimeMs, mtime: st.mtimeMs });
-        }
-        if (action === 'readdir') {
-            const entries = await readdirWithin(projectRoot, rel);
-            return jsonRes(res, 200, entries.map((e) => [e.name, e.isDirectory() ? 2 : 1]));
-        }
-        if (action === 'read') {
-            const buf = await readFileBufferWithin(projectRoot, rel);
-            res.writeHead(200, { 'Content-Type': 'application/octet-stream', 'Content-Length': buf.length });
-            return void res.end(buf);
-        }
-        if (action === 'write') {
-            let buf;
-            try {
-                buf = await readBody(req);
-            }
-            catch (e) {
-                if (e instanceof BodyTooLargeError)
-                    return jsonRes(res, 413, { error: e.message });
-                throw e;
-            }
-            await writeFileWithin(projectRoot, rel, buf);
-            res.writeHead(204);
-            return void res.end();
-        }
-        if (action === 'mkdir') {
-            await mkdirWithin(projectRoot, rel);
-            res.writeHead(204);
-            return void res.end();
-        }
-        if (action === 'delete') {
-            await deleteWithin(projectRoot, rel);
-            res.writeHead(204);
-            return void res.end();
-        }
-        if (action === 'rename') {
-            const toRel = (url.searchParams.get('to') ?? '').replace(/^\/+/, '');
-            await renameWithin(projectRoot, rel, toRel);
-            res.writeHead(204);
-            return void res.end();
-        }
+    const handler = FS_ACTIONS[action];
+    if (!handler)
         return jsonRes(res, 404, { error: 'unknown fs action: ' + action });
+    try {
+        await handler({ req, res, projectRoot, rel, url });
     }
     catch (e) {
-        return jsonRes(res, fsErrorStatus(e), { error: String(e.message), code: e.code });
+        jsonRes(res, fsErrorStatus(e), { error: String(e.message), code: e.code });
     }
 }
 /**

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

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

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

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

package/dist/main/utils/logger.d.ts

@@ -1,15 +1,8 @@
-type LogLevel = 'debug' | 'info' | 'warn' | 'error';
-export interface Logger {
-    debug(message: string, ...args: unknown[]): void;
-    info(message: string, ...args: unknown[]): void;
-    warn(message: string, ...args: unknown[]): void;
-    error(message: string, ...args: unknown[]): void;
-}
 /**
- * Create a tagged logger for a specific module.
- * All output goes to console with structured prefix.
+ * Tagged console logger. The implementation lives in
+ * `@dimina-kit/electron-deck/main` (single source — the two packages share one
+ * logger); this module re-exports it so devtools-internal imports keep their
+ * stable `utils/logger` path.
  */
-export declare function createLogger(tag: string): Logger;
-export declare function setLogLevel(level: LogLevel): void;
-export {};
+export { createLogger, setLogLevel, type Logger } from '@dimina-kit/electron-deck/main';
 //# sourceMappingURL=logger.d.ts.map

package/dist/main/utils/logger.js

@@ -1,48 +1,8 @@
-const LEVEL_PRIORITY = {
-    debug: 0,
-    info: 1,
-    warn: 2,
-    error: 3,
-};
-const LEVEL_PREFIX = {
-    debug: '[DEBUG]',
-    info: '[INFO]',
-    warn: '[WARN]',
-    error: '[ERROR]',
-};
-let currentLevel = 'debug';
-function shouldLog(level) {
-    return LEVEL_PRIORITY[level] >= LEVEL_PRIORITY[currentLevel];
-}
-function formatMessage(level, tag, message) {
-    const ts = new Date().toISOString();
-    return `${ts} ${LEVEL_PREFIX[level]} [${tag}] ${message}`;
-}
 /**
- * Create a tagged logger for a specific module.
- * All output goes to console with structured prefix.
+ * Tagged console logger. The implementation lives in
+ * `@dimina-kit/electron-deck/main` (single source — the two packages share one
+ * logger); this module re-exports it so devtools-internal imports keep their
+ * stable `utils/logger` path.
  */
-export function createLogger(tag) {
-    return {
-        debug(message, ...args) {
-            if (shouldLog('debug'))
-                console.debug(formatMessage('debug', tag, message), ...args);
-        },
-        info(message, ...args) {
-            if (shouldLog('info'))
-                console.info(formatMessage('info', tag, message), ...args);
-        },
-        warn(message, ...args) {
-            if (shouldLog('warn'))
-                console.warn(formatMessage('warn', tag, message), ...args);
-        },
-        error(message, ...args) {
-            if (shouldLog('error'))
-                console.error(formatMessage('error', tag, message), ...args);
-        },
-    };
-}
-export function setLogLevel(level) {
-    currentLevel = level;
-}
+export { createLogger, setLogLevel } from '@dimina-kit/electron-deck/main';
 //# sourceMappingURL=logger.js.map

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

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

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

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