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

package/dist/main/services/console-forward/global-diagnostics-mirror.d.ts

@@ -0,0 +1,33 @@
+import type { WebContents } from 'electron';
+import type { Disposable } from '@dimina-kit/electron-deck/main';
+import type { DiagnosticsBus } from '../diagnostics/index.js';
+import type { CdpSessionBroker } from '../cdp-session/index.js';
+/**
+ * Mirror EVERY diagnostic (both `audience:'user'` and `audience:'internal'`,
+ * UNFILTERED — the same "see everything" contract `createGlobalConsoleMirror`
+ * applies to guest console entries) into `target`'s own console, but ONLY
+ * while the standalone internal DevTools window is open.
+ *
+ * The subscription lifecycle is gated by `onHostChanged` (non-null hostWc =
+ * window just opened/rebuilt, null = just closed) rather than subscribing
+ * once for the whole app lifetime: each open re-subscribes to `diagnostics`
+ * with `{replay:true}`, draining its CURRENT buffer into `target` before
+ * continuing live, and each close disposes that subscription. This is what
+ * makes opening (or reopening) the window always show history — subscribing
+ * once at construction time (this module's earlier design) captured the
+ * replay burst before any window could possibly be open to receive it
+ * (construction happens at app boot; the window is user-opened, always
+ * later), silently losing it forever — the exact reported bug (e.g. the
+ * earliest compile-standby events at boot never showing up). `target` is the
+ * fixed INSPECTED side (mainWindow.webContents) — never the hostWc the
+ * signal carries.
+ *
+ * Reopen-dedup is handled by `createOpenGatedRelay` (real-machine e2e
+ * confirmed a naive replay-on-every-open double-injects everything already
+ * shown once, since Chromium's own console storage survives a DevTools
+ * close — see that module's doc comment).
+ */
+export declare function createGlobalDiagnosticsMirror(diagnostics: Pick<DiagnosticsBus, 'subscribe'>, target: WebContents, onHostChanged: (handler: (hostWc: WebContents | null) => void) => () => void, opts: {
+    broker: CdpSessionBroker;
+}): Disposable;
+//# sourceMappingURL=global-diagnostics-mirror.d.ts.map

package/dist/main/services/console-forward/global-diagnostics-mirror.js

@@ -0,0 +1,73 @@
+import { isFrontendSettled } from '../views/inject-when-ready.js';
+import { createOpenGatedRelay } from './open-gated-relay.js';
+import { injectViaCdp } from './cdp-inject.js';
+/** `Diagnostic.severity` → the literal `console.<method>` call — same mapping
+ *  console-forward/index.ts's DIAGNOSTIC_CONSOLE_CALL uses (kept local since
+ *  that constant isn't exported; both must stay in sync with `Diagnostic`). */
+const DIAGNOSTIC_CONSOLE_CALL = {
+    error: 'console.error',
+    warn: 'console.warn',
+    info: 'console.info',
+};
+/**
+ * Build the `executeJavaScript` source that injects one diagnostic into the
+ * target wc's own console, prefixed `[dimina-kit] ` — same shape as
+ * console-forward/index.ts's `buildDiagnosticScript`, minus that function's
+ * `RENDER_FORWARD_SOURCE_URL` loop-safety sentinel: that sentinel exists to
+ * stop the service-host's OWN CDP capture from re-broadcasting the injected
+ * line, and nothing here re-captures `mainWindow.webContents`'s console.
+ */
+function buildMirrorScript(severity, message) {
+    const call = DIAGNOSTIC_CONSOLE_CALL[severity];
+    const argsJson = JSON.stringify([`[dimina-kit] ${message}`]);
+    return `(()=>{try{const a=JSON.parse(${JSON.stringify(argsJson)});${call}(...a)}catch(_){}})()`;
+}
+/**
+ * Mirror EVERY diagnostic (both `audience:'user'` and `audience:'internal'`,
+ * UNFILTERED — the same "see everything" contract `createGlobalConsoleMirror`
+ * applies to guest console entries) into `target`'s own console, but ONLY
+ * while the standalone internal DevTools window is open.
+ *
+ * The subscription lifecycle is gated by `onHostChanged` (non-null hostWc =
+ * window just opened/rebuilt, null = just closed) rather than subscribing
+ * once for the whole app lifetime: each open re-subscribes to `diagnostics`
+ * with `{replay:true}`, draining its CURRENT buffer into `target` before
+ * continuing live, and each close disposes that subscription. This is what
+ * makes opening (or reopening) the window always show history — subscribing
+ * once at construction time (this module's earlier design) captured the
+ * replay burst before any window could possibly be open to receive it
+ * (construction happens at app boot; the window is user-opened, always
+ * later), silently losing it forever — the exact reported bug (e.g. the
+ * earliest compile-standby events at boot never showing up). `target` is the
+ * fixed INSPECTED side (mainWindow.webContents) — never the hostWc the
+ * signal carries.
+ *
+ * Reopen-dedup is handled by `createOpenGatedRelay` (real-machine e2e
+ * confirmed a naive replay-on-every-open double-injects everything already
+ * shown once, since Chromium's own console storage survives a DevTools
+ * close — see that module's doc comment).
+ */
+export function createGlobalDiagnosticsMirror(diagnostics, target, onHostChanged, opts) {
+    function inject(d) {
+        if (target.isDestroyed())
+            return false;
+        if (!isFrontendSettled(target))
+            return false;
+        let script;
+        try {
+            script = buildMirrorScript(d.severity, d.message);
+        }
+        catch {
+            return false;
+        }
+        // Transport is CDP `Runtime.evaluate` over the shared debugger-session
+        // broker — never `target.executeJavaScript`, whose internal RPC hangs
+        // forever under the setDevToolsWebContents + external-CDP-client double
+        // attach (see cdp-inject.ts / global-console-mirror.ts; same target,
+        // same failure). Report the real outcome — createOpenGatedRelay only
+        // marks an entry permanently "injected" on a confirmed `true`.
+        return injectViaCdp(opts.broker, target, script, 'global-diagnostics-mirror');
+    }
+    return createOpenGatedRelay(onHostChanged, (sink, opts2) => diagnostics.subscribe(sink, opts2), inject);
+}
+//# sourceMappingURL=global-diagnostics-mirror.js.map

package/dist/main/services/console-forward/index.d.ts

@@ -1,47 +1,2 @@
-import { type Disposable } from '@dimina-kit/electron-deck/main';
-import type { BridgeRouterHandle } from '../../ipc/bridge-router.js';
-import type { DiagnosticsBus } from '../diagnostics/index.js';
-/**
- * One console entry posted by a guest preload. Shape mirrors
- * render-host/preload.cjs + service-host/preload.cjs `emitConsoleLog`:
- *   - `source`  which layer it came from ('render' | 'service'); ONLY 'render'
- *               is forwarded into the service host (see loop-safety above).
- *   - `bridgeId` present for render entries; identifies the owning page so we
- *               can target the matching app's service host (multi-app safe).
- *   - `level`   console method name ('log' | 'warn' | 'error' | 'info' | 'debug').
- *   - `args`    already-`safeSerialize`d arguments (structured-cloneable).
- */
-export interface GuestConsoleEntry {
-    source?: string;
-    bridgeId?: string;
-    level?: string;
-    args?: unknown[];
-    ts?: number;
-}
-/** A consumer of every guest console entry (render AND service). */
-export type ConsoleSink = (entry: GuestConsoleEntry) => void;
-export interface ConsoleForwarder extends Disposable {
-    /**
-     * The single sink bridge-router invokes (wired onto `ctx.guestConsole.emit`).
-     * Fans every entry out to subscribers, then runs the render→service forward.
-     */
-    emit(entry: unknown): void;
-    /**
-     * Register an external sink (e.g. automation WS broadcast). Returns a
-     * Disposable that unregisters it. Sinks see EVERY entry (both layers) — the
-     * render→service forward is internal and not exposed as a sink.
-     */
-    subscribe(sink: ConsoleSink): Disposable;
-    /**
-     * Flush any diagnostic queued for `appSessionId` (plus the global,
-     * session-less queue) into that session's now-ready service-host wc.
-     * Idempotent: entries are removed from their bucket as they flush, so a
-     * repeat call for the same session injects nothing further. Call once the
-     * session's service-host webContents has actually navigated/loaded (e.g.
-     * from `bootServiceHost`, after `did-finish-load`) — calling it earlier just
-     * finds nothing resolvable and leaves the queue intact for a later call.
-     */
-    notifyServiceHostReady(appSessionId: string): void;
-}
-export declare function createConsoleForwarder(bridge: Pick<BridgeRouterHandle, 'getServiceWc' | 'getServiceWcForBridge'>, diagnostics?: DiagnosticsBus): ConsoleForwarder;
+export * from '@dimina-kit/electron-runtime/main/console-forward';
 //# sourceMappingURL=index.d.ts.map

package/dist/main/services/console-forward/index.js

@@ -1,186 +1,2 @@
-import { DisposableRegistry, toDisposable } from '@dimina-kit/electron-deck/main';
-import { RENDER_FORWARD_SOURCE_URL } from '../service-console/console-api.js';
-/** Console levels we re-emit into the service host. Anything else maps to 'log'. */
-const FORWARDABLE_LEVELS = new Set(['log', 'warn', 'error', 'info', 'debug']);
-/**
- * Build the `executeJavaScript` source that re-emits a render entry inside the
- * service host. Args are carried as a JSON string and parsed service-side, so no
- * guest-controlled value is ever interpolated into executable JS — the only
- * thing that reaches the parser is a JSON literal. The `[视图]` prefix lets the
- * DevTools console filter isolate the render layer.
- */
-function buildForwardScript(level, args) {
-    const method = FORWARDABLE_LEVELS.has(level) ? level : 'log';
-    // JSON.stringify('…') yields a valid JS string literal; embedding it and
-    // re-parsing keeps args as data, never code. JSON.stringify can throw on a
-    // value that slipped past safeSerialize (e.g. a BigInt) — caller guards.
-    const argsJson = JSON.stringify(args ?? []);
-    // `console[method]` (not `console.log`) preserves the original level so the
-    // DevTools severity filter still works on the forwarded line.
-    //
-    // The trailing `//# sourceURL` stamps this injected line with a sentinel URL.
-    // The service-console CDP capture (services/service-console) attached to THIS
-    // service host would otherwise re-capture this `console[...]` call as a fresh
-    // service entry and re-broadcast it to automation (duplicate). It skips any
-    // `consoleAPICalled` whose top frame URL === RENDER_FORWARD_SOURCE_URL.
-    return `(()=>{try{const a=JSON.parse(${JSON.stringify(argsJson)});console[${JSON.stringify(method)}]('[视图]',...a)}catch(_){}})()\n//# sourceURL=${RENDER_FORWARD_SOURCE_URL}`;
-}
-/** `Diagnostic.severity` → the literal `console.<method>` call to emit (dot form, not computed — kept greppable/CDP-attributable like a hand-written call site). */
-const DIAGNOSTIC_CONSOLE_CALL = {
-    error: 'console.error',
-    warn: 'console.warn',
-    info: 'console.info',
-};
-/**
- * Build the `executeJavaScript` source that injects one diagnostic into the
- * service host's console, prefixed `[dimina-kit]`. Args ride as a JSON string
- * (same anti-injection shape as `buildForwardScript`) and the sourceURL is the
- * SAME sentinel the render mirror uses, so this line is exempt from
- * service-console's loop-safety skip too.
- */
-function buildDiagnosticScript(severity, message) {
-    const call = DIAGNOSTIC_CONSOLE_CALL[severity];
-    const argsJson = JSON.stringify([`[dimina-kit] ${message}`]);
-    return `(()=>{try{const a=JSON.parse(${JSON.stringify(argsJson)});${call}(...a)}catch(_){}})()\n//# sourceURL=${RENDER_FORWARD_SOURCE_URL}`;
-}
-export function createConsoleForwarder(bridge, diagnostics) {
-    const sinks = new Set();
-    const registry = new DisposableRegistry();
-    // Diagnostics queued because no live service-host wc could be resolved yet,
-    // bucketed by the owning appSessionId; diagnostics with no appSessionId land
-    // in `pendingGlobal` instead. `notifyServiceHostReady` drains both into the
-    // session that just became ready.
-    const pendingBySession = new Map();
-    const pendingGlobal = [];
-    // Sessions whose service host has finished loading service.html (the caller
-    // signals this via `notifyServiceHostReady`). A resolvable wc alone is NOT
-    // readiness: the window exists (and is bound) before its spawn navigation
-    // lands, and anything injected into that pre-load document is wiped by the
-    // navigation — the diagnostic would silently vanish from the Console panel.
-    const readySessions = new Set();
-    function injectDiagnostic(wc, d) {
-        wc.executeJavaScript(buildDiagnosticScript(d.severity, d.message), true).catch(() => { });
-    }
-    /**
-     * Inject a diagnostic into its owning session's service-host console, or
-     * queue it until that host is READY (not merely constructed — see
-     * `readySessions`). Ownership is strict: a session-owned diagnostic NEVER
-     * falls back to the currently-active host — while `handleSpawn` is still
-     * running, the new session's host doesn't exist yet and the "active" host
-     * is the OUTGOING session's window, so a fallback would land the message in
-     * a console about to be destroyed instead of the session it explains. Only
-     * session-less diagnostics may use the active host. Never throws — a
-     * missing/destroyed/not-yet-ready host is a normal state, not an error.
-     */
-    function handleDiagnostic(d) {
-        if (d.appSessionId) {
-            const wc = readySessions.has(d.appSessionId) && bridge.getServiceWcForBridge
-                ? bridge.getServiceWcForBridge(d.appSessionId)
-                : null;
-            if (wc && !wc.isDestroyed()) {
-                injectDiagnostic(wc, d);
-                return;
-            }
-            const bucket = pendingBySession.get(d.appSessionId);
-            if (bucket)
-                bucket.push(d);
-            else
-                pendingBySession.set(d.appSessionId, [d]);
-            return;
-        }
-        const wc = bridge.getServiceWc();
-        if (wc && !wc.isDestroyed()) {
-            injectDiagnostic(wc, d);
-            return;
-        }
-        pendingGlobal.push(d);
-    }
-    if (diagnostics) {
-        // replay:true so diagnostics reported before this forwarder existed (early
-        // boot, buffered on the bus) are queued/injected here too.
-        registry.add(diagnostics.subscribe(handleDiagnostic, { replay: true }));
-    }
-    /**
-     * Render→service forward. Resolves the service host for the entry's owning
-     * page (multi-app safe), falling back to the active app's service host when
-     * the bridgeId is unknown — that's the host the embedded DevTools inspects.
-     * No-op on a destroyed/missing host so we never write to a torn-down wc (pool
-     * reuse / session swap can swap the host out under us).
-     */
-    function forwardRenderToServiceHost(entry) {
-        let wc = null;
-        if (entry.bridgeId && bridge.getServiceWcForBridge) {
-            wc = bridge.getServiceWcForBridge(entry.bridgeId);
-        }
-        if (!wc)
-            wc = bridge.getServiceWc();
-        if (!wc || wc.isDestroyed())
-            return;
-        let script;
-        try {
-            script = buildForwardScript(entry.level ?? 'log', entry.args ?? []);
-        }
-        catch {
-            // Args that escaped safeSerialize and aren't JSON-stringifiable — drop
-            // rather than break the forward. Console capture must never throw.
-            return;
-        }
-        // executeJavaScript rejects if the host navigates/teardowns mid-call; the
-        // injected body is itself try/caught. Swallow either — best-effort mirror.
-        wc.executeJavaScript(script, true).catch(() => { });
-    }
-    return {
-        // The single sink bridge-router calls (`ctx.guestConsole.emit`). Fans out
-        // to external subscribers (both layers) then runs the render→service forward
-        // (render only — see loop-safety invariant in the module header).
-        emit(raw) {
-            const entry = (raw ?? {});
-            for (const sink of sinks) {
-                try {
-                    sink(entry);
-                }
-                catch { /* a sink must never break the others */ }
-            }
-            // Forward ONLY the render layer. Service entries are already shown
-            // natively in the attached DevTools, and forwarding them would loop
-            // (see header).
-            if (entry.source === 'render')
-                forwardRenderToServiceHost(entry);
-        },
-        subscribe(sink) {
-            sinks.add(sink);
-            return registry.add(toDisposable(() => { sinks.delete(sink); }));
-        },
-        notifyServiceHostReady(appSessionId) {
-            // Readiness is sticky per session: from here on, session-owned
-            // diagnostics inject directly instead of queueing.
-            readySessions.add(appSessionId);
-            // Re-resolve fresh rather than trusting whatever `handleDiagnostic` saw at
-            // report time — the caller invokes this exactly when it knows the wc just
-            // became live, so that resolution wins even if an earlier snapshot was
-            // destroyed/missing.
-            const wc = bridge.getServiceWcForBridge ? bridge.getServiceWcForBridge(appSessionId) : null;
-            if (!wc)
-                return;
-            const sessionEntries = pendingBySession.get(appSessionId);
-            if (sessionEntries) {
-                for (const d of sessionEntries)
-                    injectDiagnostic(wc, d);
-                pendingBySession.delete(appSessionId);
-            }
-            if (pendingGlobal.length) {
-                for (const d of pendingGlobal)
-                    injectDiagnostic(wc, d);
-                pendingGlobal.length = 0;
-            }
-        },
-        dispose() {
-            sinks.clear();
-            pendingBySession.clear();
-            pendingGlobal.length = 0;
-            readySessions.clear();
-            return registry.disposeAll();
-        },
-    };
-}
+export * from '@dimina-kit/electron-runtime/main/console-forward';
 //# sourceMappingURL=index.js.map

package/dist/main/services/console-forward/internal-log.d.ts

@@ -0,0 +1,2 @@
+export * from '@dimina-kit/electron-runtime/main/internal-log';
+//# sourceMappingURL=internal-log.d.ts.map

package/dist/main/services/console-forward/internal-log.js

@@ -0,0 +1,2 @@
+export * from '@dimina-kit/electron-runtime/main/internal-log';
+//# sourceMappingURL=internal-log.js.map

package/dist/main/services/console-forward/open-gated-relay.d.ts

@@ -0,0 +1,67 @@
+import type { Disposable } from '@dimina-kit/electron-deck/main';
+/**
+ * Generic open/close-gated replay-subscription primitive shared by
+ * `createGlobalConsoleMirror` and `createGlobalDiagnosticsMirror` — both
+ * gate their subscription to a buffered+replayable source
+ * (`ConsoleForwarder`/`DiagnosticsBus`) on whether the standalone "debug the
+ * whole Electron app" window is currently open (`onHostChanged`): each open
+ * re-subscribes with `{replay:true}` so history is never lost even if the
+ * window opens long after boot, and each close disposes that subscription.
+ *
+ * ── Dedup (the e2e-confirmed bug this fixes) ────────────────────────────────
+ * Naively re-subscribing with `{replay:true}` on every reopen double-injects
+ * history: Chromium's own per-frame `ConsoleMessageStorage` is NOT cleared by
+ * closing DevTools (only by navigation), so it natively re-delivers entries
+ * already shown during a PREVIOUS open to the freshly-attached front-end —
+ * and if this relay ALSO blindly replays and re-injects the same buffered
+ * objects, every entry shown once ends up displayed twice on reopen, the
+ * duplicate carrying a fresh (wrong) "just reopened" timestamp instead of
+ * when it actually happened.
+ *
+ * Fix: `state` is a `WeakMap` keyed by OBJECT REFERENCE (never content — two
+ * content-identical-but-distinct entries must each still get injected once)
+ * that persists across the relay's ENTIRE lifetime, not reset by open/close.
+ * A replay that re-delivers an already-CONFIRMED-injected object is skipped;
+ * only entries never physically (and successfully) passed to `inject()`
+ * before (e.g. ones that arrived while the window was closed) actually call
+ * `inject()`. Chromium's own native re-delivery is left to show the
+ * once-injected ones — that is what makes reopening not double them up. This
+ * also composes correctly with the source's own bounded ring buffer: an
+ * evicted entry is simply absent from the next replay batch entirely, so it
+ * can never be double-counted regardless of what `state` holds.
+ *
+ * ── inject() is fallible — only a CONFIRMED success may ever mark "done" ───
+ * `inject()` wraps an async `executeJavaScript` against a possibly-destroyed
+ * or not-yet-settled target, so it reports whether the entry was ACTUALLY
+ * delivered via `boolean | Promise<boolean>`. Marking an entry "injected"
+ * before that outcome is known (the original bug here) means a single
+ * transient failure — target destroyed, front-end not settled, a rejected
+ * `executeJavaScript` — permanently black-holes that entry: every future
+ * replay skips it forever, even though it was never actually shown anywhere
+ * (violates this repo's "state must be marked at the moment the fact
+ * actually happens" principle — this was marking INTENT, not the fact). So
+ * `state` tracks three phases per entry: absent (never attempted, or a prior
+ * attempt failed and was cleared — eligible for `inject()`), `'pending'`
+ * (an `inject()` call is in flight — a concurrent replay of the SAME entry
+ * must not trigger a second concurrent call), `'done'` (confirmed success —
+ * permanently skipped from here on). A `false` result or a rejection resets
+ * the entry back to absent, so the next replay (e.g. the next window reopen)
+ * gets a real retry instead of a silent, permanent loss.
+ */
+export interface OpenGatedRelayOptions {
+    /**
+     * Bounds how long ONE in-flight `inject()` attempt may hold an entry
+     * `'pending'`. An `inject()` promise that never settles (real incident:
+     * `executeJavaScript` against a wc that is simultaneously the inspected
+     * side of `setDevToolsWebContents` AND attached by an external CDP client
+     * hangs forever) would otherwise black-hole the entry permanently — never
+     * shown, never retried. Past this bound the entry becomes retryable again
+     * on the next replay. The timed-out attempt's promise may still settle
+     * LATE; its settlement is generation-stamped and ignored when stale.
+     */
+    injectTimeoutMs?: number;
+}
+export declare function createOpenGatedRelay<TEntry extends object, THost = unknown>(onHostChanged: (handler: (host: THost | null) => void) => () => void, subscribe: (sink: (entry: TEntry) => void, opts: {
+    replay: true;
+}) => Disposable, inject: (entry: TEntry) => boolean | Promise<boolean>, opts?: OpenGatedRelayOptions): Disposable;
+//# sourceMappingURL=open-gated-relay.d.ts.map

package/dist/main/services/console-forward/open-gated-relay.js

@@ -0,0 +1,55 @@
+const DEFAULT_INJECT_TIMEOUT_MS = 10_000;
+export function createOpenGatedRelay(onHostChanged, subscribe, inject, opts) {
+    const injectTimeoutMs = opts?.injectTimeoutMs ?? DEFAULT_INJECT_TIMEOUT_MS;
+    // Generation stamp per attempt: only the attempt matching the entry's
+    // CURRENT pending generation may act on settling — a stale (timed-out,
+    // superseded) attempt's late result must neither mark the entry done nor
+    // disturb a newer attempt's pending status.
+    const state = new WeakMap();
+    let generationSeq = 0;
+    const inFlightTimers = new Set();
+    let live = null;
+    function deliver(entry) {
+        if (state.has(entry))
+            return;
+        const generation = ++generationSeq;
+        state.set(entry, { phase: 'pending', generation });
+        const timer = setTimeout(() => {
+            inFlightTimers.delete(timer);
+            const cur = state.get(entry);
+            if (cur && cur.phase === 'pending' && cur.generation === generation)
+                state.delete(entry);
+        }, injectTimeoutMs);
+        timer.unref?.();
+        inFlightTimers.add(timer);
+        const settle = (ok) => {
+            clearTimeout(timer);
+            inFlightTimers.delete(timer);
+            const cur = state.get(entry);
+            if (!cur || cur.phase !== 'pending' || cur.generation !== generation)
+                return;
+            if (ok)
+                state.set(entry, { phase: 'done', generation });
+            else
+                state.delete(entry);
+        };
+        Promise.resolve()
+            .then(() => inject(entry))
+            .then((ok) => settle(ok === true), () => settle(false));
+    }
+    const unregister = onHostChanged((host) => {
+        live?.dispose();
+        live = host !== null ? subscribe(deliver, { replay: true }) : null;
+    });
+    return {
+        dispose: () => {
+            for (const timer of inFlightTimers)
+                clearTimeout(timer);
+            inFlightTimers.clear();
+            live?.dispose();
+            live = null;
+            unregister();
+        },
+    };
+}
+//# sourceMappingURL=open-gated-relay.js.map

package/dist/main/services/default-adapter.js

@@ -5,7 +5,7 @@ export const defaultAdapter = {
     async openProject(opts) {
         const diminaKit = await import('@dimina-kit/devkit');
         const openProjectOpts = {
-            outputDir: path.join(app.getPath('userData'), 'dimina-fe-output'),
+            outputRoot: path.join(app.getPath('userData'), 'dimina-fe-output'),
             ...opts,
             simulatorDir,
         };

package/dist/main/services/diagnostics/index.d.ts

@@ -1,49 +1,2 @@
-/**
- * Diagnostics bus: the single authoritative channel for developer-facing
- * diagnostics synthesized by main (e.g. "page not found", "logic bundle
- * unreachable") that do not originate from a real `console.*` call the
- * embedded service-host DevTools' CDP capture could observe on its own.
- *
- * Main-synthesized diagnostics used to reach only `ctx.guestConsole.emit`,
- * which fans out to automation subscribers but — for `source:'service'`
- * entries — is never injected into the service host's own console (see
- * `console-forward`'s render-only forward invariant), so they never appeared
- * in the Console panel. This bus is the fix: `report()` is the one place a
- * diagnostic is born, and `console-forward` subscribes to inject each one
- * into the owning session's service-host console (queuing until that
- * session's window is ready — see `notifyServiceHostReady`).
- */
-export type DiagnosticSeverity = 'error' | 'warn' | 'info';
-export interface Diagnostic {
-    severity: DiagnosticSeverity;
-    code: string;
-    message: string;
-    appSessionId?: string;
-    ts: number;
-}
-export interface DiagnosticsBus {
-    /** Record one diagnostic: buffers it, mirrors it to the main-process console, and synchronously notifies every live subscriber. No-op after `dispose()`. */
-    report(d: {
-        severity: DiagnosticSeverity;
-        code: string;
-        message: string;
-        appSessionId?: string;
-    }): void;
-    /**
-     * Register a sink. With `replay` (default true) the sink is first called,
-     * in order, for every buffered diagnostic still held, then for every
-     * diagnostic reported from now on; `replay: false` skips the backlog and
-     * only delivers diagnostics reported after this call.
-     */
-    subscribe(sink: (d: Diagnostic) => void, opts?: {
-        replay?: boolean;
-    }): {
-        dispose(): void;
-    };
-    /** Clears subscribers and the buffer. `report()` becomes a no-op afterward (including the console mirror — dispose means fully off, not "log-only"). */
-    dispose(): void;
-}
-export declare function createDiagnosticsBus(opts?: {
-    bufferCap?: number;
-}): DiagnosticsBus;
+export * from '@dimina-kit/electron-runtime/main/diagnostics';
 //# sourceMappingURL=index.d.ts.map

package/dist/main/services/diagnostics/index.js

@@ -1,61 +1,2 @@
-const DEFAULT_BUFFER_CAP = 200;
-const CONSOLE_METHOD = {
-    error: 'error',
-    warn: 'warn',
-    info: 'info',
-};
-export function createDiagnosticsBus(opts) {
-    const bufferCap = opts?.bufferCap && opts.bufferCap > 0 ? opts.bufferCap : DEFAULT_BUFFER_CAP;
-    const buffer = [];
-    const sinks = new Set();
-    let disposed = false;
-    return {
-        report(d) {
-            if (disposed)
-                return;
-            const entry = { ...d, ts: Date.now() };
-            buffer.push(entry);
-            // Ring buffer: drop the oldest once over cap. Bounded at `bufferCap` so a
-            // burst of synthesized diagnostics can never grow this without limit.
-            if (buffer.length > bufferCap)
-                buffer.shift();
-            // The one guaranteed-visible sink: unlike Console-panel injection (which
-            // needs a live, ready service-host wc), the main-process terminal is
-            // always there.
-            console[CONSOLE_METHOD[entry.severity]](`[dimina-kit:${entry.code}] ${entry.message}`);
-            for (const sink of sinks) {
-                try {
-                    sink(entry);
-                }
-                catch { /* a sink must never break the others */ }
-            }
-        },
-        subscribe(sink, subOpts) {
-            const replay = subOpts?.replay ?? true;
-            if (replay) {
-                for (const entry of buffer) {
-                    try {
-                        sink(entry);
-                    }
-                    catch { /* isolate a replay throw same as a live one */ }
-                }
-            }
-            sinks.add(sink);
-            let released = false;
-            return {
-                dispose() {
-                    if (released)
-                        return;
-                    released = true;
-                    sinks.delete(sink);
-                },
-            };
-        },
-        dispose() {
-            disposed = true;
-            sinks.clear();
-            buffer.length = 0;
-        },
-    };
-}
+export * from '@dimina-kit/electron-runtime/main/diagnostics';
 //# sourceMappingURL=index.js.map

package/dist/main/services/dimina-resource-server.d.ts

@@ -1,7 +1,2 @@
-export interface DiminaResourceServer {
-    baseUrl: string;
-    close(): Promise<void>;
-}
-export declare function startDiminaResourceServer(rootDir: string): Promise<DiminaResourceServer>;
-export declare function toSourceUrl(filePath: string): string;
+export * from '@dimina-kit/electron-runtime/main/dimina-resource-server';
 //# sourceMappingURL=dimina-resource-server.d.ts.map