@dimina-kit/devtools 0.4.0-dev.20260729062524 → 0.4.0-dev.20260801163345

package/dist/main/ipc/page-scroll.d.ts

@@ -1,14 +1,2 @@
-/**
- * Build the script that `wx.pageScrollTo` runs inside the page's render guest.
- *
- * The mini-program page scrolls the whole render document (the native iOS impl
- * scrolls the WKWebView's scrollView; Android scrolls the page view), so the
- * simulator scrolls `window`. `duration` is best-effort: a positive duration
- * maps to smooth scrolling (the browser owns the easing — the exact ms is not
- * controllable), and `0` jumps instantly.
- */
-export declare function buildPageScrollScript(params: {
-    scrollTop?: unknown;
-    duration?: unknown;
-}): string;
+export * from '@dimina-kit/electron-runtime/main/page-scroll';
 //# sourceMappingURL=page-scroll.d.ts.map

package/dist/main/ipc/page-scroll.js

@@ -1,17 +1,2 @@
-/**
- * Build the script that `wx.pageScrollTo` runs inside the page's render guest.
- *
- * The mini-program page scrolls the whole render document (the native iOS impl
- * scrolls the WKWebView's scrollView; Android scrolls the page view), so the
- * simulator scrolls `window`. `duration` is best-effort: a positive duration
- * maps to smooth scrolling (the browser owns the easing — the exact ms is not
- * controllable), and `0` jumps instantly.
- */
-export function buildPageScrollScript(params) {
-    const rawTop = Number(params.scrollTop);
-    const top = Number.isFinite(rawTop) ? rawTop : 0;
-    const duration = params.duration === undefined ? 300 : Number(params.duration);
-    const behavior = Number.isFinite(duration) && duration > 0 ? 'smooth' : 'auto';
-    return `window.scrollTo({ top: ${top}, left: 0, behavior: ${JSON.stringify(behavior)} })`;
-}
+export * from '@dimina-kit/electron-runtime/main/page-scroll';
 //# sourceMappingURL=page-scroll.js.map

package/dist/main/ipc/session-listener-bag.d.ts

@@ -1,41 +1,2 @@
-/**
- * Session-scoped listener bookkeeping. An app session hangs lifecycle hooks on
- * emitters it does NOT own — the shared simulator WebContentsView, a pooled
- * service-host window — and those emitters outlive the session (one simulator
- * wc soft-reloads through many sessions). Every such hook is registered
- * through this bag so the session's single teardown chokepoint can detach them
- * all with one `dispose()`; a hook left behind survives as a dead listener on
- * the shared emitter, growing by one per soft reload until Node's MaxListeners
- * warning fires.
- */
-type Listener = (...args: unknown[]) => void;
-/**
- * Structural surface of the Node/Electron emitters the bag manages.
- * `removeListener(event, fn)` also detaches a `once(event, fn)` registration:
- * Node's once wrapper keeps a `.listener` back-reference to `fn` and
- * removeListener matches through it. `isDestroyed` covers Electron objects
- * (WebContents / BrowserWindow) whose methods throw once destroyed.
- */
-export interface BagEmitter {
-    on(event: string, listener: Listener): unknown;
-    once(event: string, listener: Listener): unknown;
-    removeListener(event: string, listener: Listener): unknown;
-    isDestroyed?(): boolean;
-}
-export interface SessionListenerBag {
-    /** Attach `fn` via `emitter.on` and track it for dispose. No-op after dispose. */
-    on(emitter: BagEmitter, event: string, fn: Listener): void;
-    /** Attach `fn` via `emitter.once` and track it for dispose. No-op after dispose. */
-    once(emitter: BagEmitter, event: string, fn: Listener): void;
-    /**
-     * Detach every tracked listener that may still be attached. Emitters that
-     * report `isDestroyed()` are skipped — their listeners died with them, and
-     * touching a destroyed Electron object throws. Removing a `once` that
-     * already fired is a no-op, so dispose is safe to call FROM one of the
-     * bag's own hooks (teardown triggered by the hook itself). Idempotent.
-     */
-    dispose(): void;
-}
-export declare function createSessionListenerBag(): SessionListenerBag;
-export {};
+export * from '@dimina-kit/electron-runtime/main/session-listener-bag';
 //# sourceMappingURL=session-listener-bag.d.ts.map

package/dist/main/ipc/session-listener-bag.js

@@ -1,40 +1,2 @@
-/**
- * Session-scoped listener bookkeeping. An app session hangs lifecycle hooks on
- * emitters it does NOT own — the shared simulator WebContentsView, a pooled
- * service-host window — and those emitters outlive the session (one simulator
- * wc soft-reloads through many sessions). Every such hook is registered
- * through this bag so the session's single teardown chokepoint can detach them
- * all with one `dispose()`; a hook left behind survives as a dead listener on
- * the shared emitter, growing by one per soft reload until Node's MaxListeners
- * warning fires.
- */
-export function createSessionListenerBag() {
-    const records = [];
-    let disposed = false;
-    return {
-        on(emitter, event, fn) {
-            if (disposed)
-                return;
-            emitter.on(event, fn);
-            records.push({ emitter, event, fn });
-        },
-        once(emitter, event, fn) {
-            if (disposed)
-                return;
-            emitter.once(event, fn);
-            records.push({ emitter, event, fn });
-        },
-        dispose() {
-            if (disposed)
-                return;
-            disposed = true;
-            for (const { emitter, event, fn } of records) {
-                if (emitter.isDestroyed?.())
-                    continue;
-                emitter.removeListener(event, fn);
-            }
-            records.length = 0;
-        },
-    };
-}
+export * from '@dimina-kit/electron-runtime/main/session-listener-bag';
 //# sourceMappingURL=session-listener-bag.js.map

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

@@ -1,61 +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.
-     *
-     * A bounded history buffer (200 entries, oldest dropped first — mirrors
-     * `DiagnosticsBus`'s `DEFAULT_BUFFER_CAP` ring-buffer style) records every
-     * entry regardless of whether anyone is subscribed. `opts.replay` (default
-     * `false`, UNLIKE `DiagnosticsBus` whose default is `true`) opts a new
-     * subscriber into draining that buffer, in order, before receiving live
-     * entries. Default stays non-replaying because the existing automation
-     * subscriber (`services/automation/index.ts`) wants only entries from the
-     * moment it subscribes — a history dump on an existing WS connection would
-     * be a surprise duplicate broadcast. `{replay:true}` exists for the global
-     * console mirror, whose whole point is to catch up a standalone debug
-     * window opened well after boot.
-     */
-    subscribe(sink: ConsoleSink, opts?: {
-        replay?: boolean;
-    }): 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,226 +1,2 @@
-import { DisposableRegistry, toDisposable } from '@dimina-kit/electron-deck/main';
-import { RENDER_FORWARD_SOURCE_URL } from '../service-console/console-api.js';
-import { isInternalLogMessage } from './internal-log.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();
-    // Bounded history ring buffer backing `subscribe(sink, {replay:true})` —
-    // see the interface doc comment above. Every entry is recorded regardless
-    // of whether anyone is subscribed, so a replaying subscriber that arrives
-    // long after boot (the standalone global debug window) still catches up.
-    const CONSOLE_BUFFER_CAP = 200;
-    const buffer = [];
-    // 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) {
-        // Internal-audience diagnostics (e.g. compile-standby's warm-pool
-        // lifecycle) are devtools-tooling-only state — never inject them into a
-        // project's service host (the right-panel CDP is natively attached
-        // there), and never queue them either: queuing exists so a diagnostic
-        // survives until ITS session's host becomes resolvable, which is
-        // meaningless for something that must never reach any service host.
-        // (See global-diagnostics-mirror.ts for where these actually surface —
-        // the independent, unfiltered "debug the whole app" panel.)
-        if (d.audience === 'internal')
-            return;
-        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). Skips dimina
-     * framework-internal render-layer log lines (`isInternalLogMessage`) —
-     * those must never reach the project's right-panel console at all (the
-     * global console mirror still sees them via the `sinks` broadcast in
-     * `emit()`, which runs before this function). This is the source-level fix
-     * for the render half of the noise console-filter.ts's front-end text
-     * filter used to paper over; the service-layer half (`[service]` lines,
-     * native CDP-observed, no interception point available — see
-     * service-host/preload.cjs's "console.* is deliberately NOT patched"
-     * comment) still needs that filter.
-     */
-    function forwardRenderToServiceHost(entry) {
-        if (isInternalLogMessage(entry))
-            return;
-        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 ?? {});
-            buffer.push(entry);
-            if (buffer.length > CONSOLE_BUFFER_CAP)
-                buffer.shift();
-            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, opts) {
-            if (opts?.replay) {
-                for (const entry of buffer) {
-                    try {
-                        sink(entry);
-                    }
-                    catch { /* isolate a replay throw same as a live one */ }
-                }
-            }
-            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();
-            buffer.length = 0;
-            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

@@ -1,11 +1,2 @@
-import type { GuestConsoleEntry } from './index.js';
-/**
- * Judges whether a guest console entry is dimina framework-internal output
- * (a bridge/lifecycle log the framework itself prints) rather than the
- * mini-app author's own business `console.*` call. Only the FIRST arg is
- * inspected — framework logs always lead with the literal tag; a
- * business log that happens to mention the tag later in its args must not
- * be swept up.
- */
-export declare function isInternalLogMessage(entry: GuestConsoleEntry): boolean;
+export * from '@dimina-kit/electron-runtime/main/internal-log';
 //# sourceMappingURL=internal-log.d.ts.map

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

@@ -1,23 +1,2 @@
-/** dimina framework internal-log first-arg prefixes, from the framework
- *  source literals (dimina/fe/packages/service/src/core/message.js:26 and
- *  siblings use `'[service]'`; dimina/fe/packages/render/src/core/message.js:18
- *  and siblings use `'[system]'`). */
-const SERVICE_PREFIX = '[service]';
-const RENDER_PREFIX = '[system]';
-/**
- * Judges whether a guest console entry is dimina framework-internal output
- * (a bridge/lifecycle log the framework itself prints) rather than the
- * mini-app author's own business `console.*` call. Only the FIRST arg is
- * inspected — framework logs always lead with the literal tag; a
- * business log that happens to mention the tag later in its args must not
- * be swept up.
- */
-export function isInternalLogMessage(entry) {
-    const first = entry.args?.[0];
-    if (typeof first !== 'string')
-        return false;
-    if (first === RENDER_PREFIX)
-        return true;
-    return first === SERVICE_PREFIX || first.startsWith(`${SERVICE_PREFIX} `);
-}
+export * from '@dimina-kit/electron-runtime/main/internal-log';
 //# sourceMappingURL=internal-log.js.map

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

@@ -1,59 +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;
-    /**
-     * Who this diagnostic is for. `'internal'` means devtools-tooling-only
-     * state (e.g. compile-standby's warm-pool lifecycle) that must never reach
-     * the per-project service-host console the right-panel CDP is attached to
-     * — see `console-forward/index.ts`'s `handleDiagnostic` gate. `'user'` or
-     * omitted means the existing behavior: a real diagnostic about the
-     * inspected mini-program, injected into that project's Console panel.
-     */
-    audience?: 'user' | 'internal';
-}
-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;
-        audience?: 'user' | 'internal';
-    }): 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