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

package/dist/preload/runtime/host-dialog-advertiser.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Reverse size-advertiser preload for the host-controllable dialog
+ * WebContentsView. Runs in that WCV's OWN renderer (the dialog content's
+ * preload). Unlike the toolbar/sidebar (single-axis persistent strips), the
+ * dialog self-sizes on BOTH axes — it has no renderer placeholder to anchor
+ * against, so main centers it in the main window purely from what this
+ * advertiser reports. Two independent `createSizeAdvertiser` instances (one
+ * per axis) share the same root and the same outbound channel
+ * (`HostDialogAdvertiseSize` carries `{ axis, extent }` for either axis); main
+ * re-centers using whichever axes it has measured so far (see
+ * `host-dialog-view.ts`'s `reportMeasuredExtent` / default-size fallback).
+ */
+/**
+ * Attach both axis advertisers to the dialog content's shrink-to-fit root
+ * (`[data-host-dialog-root]`), waiting for it if necessary — the root may be
+ * mounted asynchronously by a framework rather than present in the initial
+ * HTML. That element MUST be shrink-to-fit on BOTH axes — same footgun as
+ * the toolbar/sidebar (`createSizeAdvertiser`'s single-axis-ownership
+ * requirement), just doubled.
+ */
+export declare function installHostDialogAdvertiserWhenReady(): void;
+//# sourceMappingURL=host-dialog-advertiser.d.ts.map

package/dist/preload/runtime/host-dialog-advertiser.js

@@ -0,0 +1,37 @@
+/**
+ * Reverse size-advertiser preload for the host-controllable dialog
+ * WebContentsView. Runs in that WCV's OWN renderer (the dialog content's
+ * preload). Unlike the toolbar/sidebar (single-axis persistent strips), the
+ * dialog self-sizes on BOTH axes — it has no renderer placeholder to anchor
+ * against, so main centers it in the main window purely from what this
+ * advertiser reports. Two independent `createSizeAdvertiser` instances (one
+ * per axis) share the same root and the same outbound channel
+ * (`HostDialogAdvertiseSize` carries `{ axis, extent }` for either axis); main
+ * re-centers using whichever axes it has measured so far (see
+ * `host-dialog-view.ts`'s `reportMeasuredExtent` / default-size fallback).
+ */
+import { ipcRenderer } from 'electron';
+import { createSizeAdvertiser } from '@dimina-kit/view-anchor';
+import { ViewChannel } from '../../shared/ipc-channels-overlays.js';
+import { whenSlotRootReady } from './wait-for-slot-root.js';
+/**
+ * Attach both axis advertisers to the dialog content's shrink-to-fit root
+ * (`[data-host-dialog-root]`), waiting for it if necessary — the root may be
+ * mounted asynchronously by a framework rather than present in the initial
+ * HTML. That element MUST be shrink-to-fit on BOTH axes — same footgun as
+ * the toolbar/sidebar (`createSizeAdvertiser`'s single-axis-ownership
+ * requirement), just doubled.
+ */
+export function installHostDialogAdvertiserWhenReady() {
+    whenSlotRootReady('[data-host-dialog-root]', '[host-dialog-advertiser] no `[data-host-dialog-root]` element found — ' +
+        'not advertising a size yet. The dialog content must wrap itself in a ' +
+        'shrink-to-fit `[data-host-dialog-root]` element so its size is the ' +
+        'content size, not the host-given view size.', (root) => {
+        const publish = (size) => {
+            ipcRenderer.send(ViewChannel.HostDialogAdvertiseSize, size);
+        };
+        createSizeAdvertiser(root, { axis: 'block', publish });
+        createSizeAdvertiser(root, { axis: 'inline', publish });
+    });
+}
+//# sourceMappingURL=host-dialog-advertiser.js.map

package/dist/preload/runtime/host-dialog-port.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Preload side of the host-dialog gated narrow channel.
+ *
+ * ── PUBLIC SURFACE EVOLUTION RULE ───────────────────────────────────────────
+ * `window.diminaHostDialog` is a published page-facing API, typed by the
+ * exported `DiminaHostDialogPageBridge` (src/main/runtime/miniapp-runtime.ts)
+ * — arbitrary host dialog pages compile against it. Members may only be
+ * ADDED, never changed: any semantic change to an existing member (signature,
+ * return shape, queueing/throw behavior) ships under a NEW name instead.
+ * Exception: security fixes / compliance corrections may change existing
+ * member semantics, and MUST be called out in the release's version notes.
+ * Keep the exported bridge type in lockstep with what is exposed here.
+ *
+ * Receives the per-load MessagePort main transfers on `did-finish-load`
+ * (`ViewChannel.HostDialogPort`, `event.ports[0]`) and bridges it to the page
+ * as `window.diminaHostDialog` — EXACTLY `{ send, onMessage }`, functions
+ * only. The raw MessagePort never crosses into the main world: the page only
+ * ever talks through these two functions, so the `{ channel, payload }`
+ * envelope stays the single waist (same posture as the main side's
+ * host-dialog-port-channel.ts).
+ *
+ * Ordering reality this module absorbs — identical to the toolbar's port
+ * bridge (see host-toolbar-port.ts for the full rationale): pre-handshake
+ * sends queue and bounded-drop, handlers register before the port exists and
+ * re-attach across same-load re-handshakes, inbound dispatch drops malformed
+ * envelopes without throwing.
+ *
+ * Shared implementation: see `host-slot-port-bridge.ts` (the toolbar/sidebar/
+ * dialog port bridges are otherwise identical; only the constants below
+ * differ).
+ */
+/**
+ * Cap on pre-handshake queued sends. Same rationale and value as
+ * `HOST_TOOLBAR_PENDING_LIMIT` — overflow drops the NEWEST envelope, one
+ * console.warn per load.
+ */
+export declare const HOST_DIALOG_PENDING_LIMIT = 128;
+/**
+ * Subscribe the handshake channel and expose the page bridge. Call ONLY from
+ * a passing dialog-runtime guard (`activateHostDialogRuntime`) — a failing
+ * guard must leave zero footprint (no bridge key, no IPC listener).
+ */
+export declare function installHostDialogPortBridge(): void;
+//# sourceMappingURL=host-dialog-port.d.ts.map

package/dist/preload/runtime/host-dialog-port.js

@@ -0,0 +1,53 @@
+/**
+ * Preload side of the host-dialog gated narrow channel.
+ *
+ * ── PUBLIC SURFACE EVOLUTION RULE ───────────────────────────────────────────
+ * `window.diminaHostDialog` is a published page-facing API, typed by the
+ * exported `DiminaHostDialogPageBridge` (src/main/runtime/miniapp-runtime.ts)
+ * — arbitrary host dialog pages compile against it. Members may only be
+ * ADDED, never changed: any semantic change to an existing member (signature,
+ * return shape, queueing/throw behavior) ships under a NEW name instead.
+ * Exception: security fixes / compliance corrections may change existing
+ * member semantics, and MUST be called out in the release's version notes.
+ * Keep the exported bridge type in lockstep with what is exposed here.
+ *
+ * Receives the per-load MessagePort main transfers on `did-finish-load`
+ * (`ViewChannel.HostDialogPort`, `event.ports[0]`) and bridges it to the page
+ * as `window.diminaHostDialog` — EXACTLY `{ send, onMessage }`, functions
+ * only. The raw MessagePort never crosses into the main world: the page only
+ * ever talks through these two functions, so the `{ channel, payload }`
+ * envelope stays the single waist (same posture as the main side's
+ * host-dialog-port-channel.ts).
+ *
+ * Ordering reality this module absorbs — identical to the toolbar's port
+ * bridge (see host-toolbar-port.ts for the full rationale): pre-handshake
+ * sends queue and bounded-drop, handlers register before the port exists and
+ * re-attach across same-load re-handshakes, inbound dispatch drops malformed
+ * envelopes without throwing.
+ *
+ * Shared implementation: see `host-slot-port-bridge.ts` (the toolbar/sidebar/
+ * dialog port bridges are otherwise identical; only the constants below
+ * differ).
+ */
+import { ViewChannel } from '../../shared/ipc-channels-overlays.js';
+import { createHostSlotPortBridge } from './host-slot-port-bridge.js';
+/**
+ * Cap on pre-handshake queued sends. Same rationale and value as
+ * `HOST_TOOLBAR_PENDING_LIMIT` — overflow drops the NEWEST envelope, one
+ * console.warn per load.
+ */
+export const HOST_DIALOG_PENDING_LIMIT = 128;
+/**
+ * Subscribe the handshake channel and expose the page bridge. Call ONLY from
+ * a passing dialog-runtime guard (`activateHostDialogRuntime`) — a failing
+ * guard must leave zero footprint (no bridge key, no IPC listener).
+ */
+export function installHostDialogPortBridge() {
+    createHostSlotPortBridge({
+        bridgeKey: 'diminaHostDialog',
+        channel: ViewChannel.HostDialogPort,
+        pendingLimit: HOST_DIALOG_PENDING_LIMIT,
+        label: 'host-dialog',
+    });
+}
+//# sourceMappingURL=host-dialog-port.js.map

package/dist/preload/runtime/host-dialog-runtime.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Session-resident host-dialog framework runtime: GUARD + ACTIVATION.
+ *
+ * Same registration and guard shape as host-toolbar-runtime.ts (see that
+ * module for the full rationale): registered once per process on
+ * `session.defaultSession`, so it runs in EVERY defaultSession renderer;
+ * this guard keeps it inert everywhere except the host-dialog WCV's main
+ * frame, identified by `HOST_DIALOG_RUNTIME_MARKER` in that process' argv.
+ */
+/**
+ * Pure guard predicate: should the dialog runtime activate in a renderer with
+ * this `argv` / `isMainFrame`? True only for the MAIN frame of a process whose
+ * argv carries the `'--dimina-host-dialog'` marker.
+ */
+export declare function shouldActivateHostDialogRuntime(argv: readonly string[], isMainFrame: boolean): boolean;
+/**
+ * Run the guard; only when it passes, install the dual-axis size advertiser
+ * (`installHostDialogAdvertiserWhenReady`) and the narrow-channel page
+ * bridge (`installHostDialogPortBridge` — `window.diminaHostDialog` +
+ * the MessagePort handshake listener). Returns whether the runtime
+ * activated. A failed guard installs NOTHING (zero footprint in non-dialog
+ * windows and subframes: no advertiser, no bridge key, no IPC listener).
+ */
+export declare function activateHostDialogRuntime(env: {
+    argv: readonly string[];
+    isMainFrame: boolean;
+}): boolean;
+//# sourceMappingURL=host-dialog-runtime.d.ts.map

package/dist/preload/runtime/host-dialog-runtime.js

@@ -0,0 +1,36 @@
+/**
+ * Session-resident host-dialog framework runtime: GUARD + ACTIVATION.
+ *
+ * Same registration and guard shape as host-toolbar-runtime.ts (see that
+ * module for the full rationale): registered once per process on
+ * `session.defaultSession`, so it runs in EVERY defaultSession renderer;
+ * this guard keeps it inert everywhere except the host-dialog WCV's main
+ * frame, identified by `HOST_DIALOG_RUNTIME_MARKER` in that process' argv.
+ */
+import { HOST_DIALOG_RUNTIME_MARKER } from '../../shared/constants.js';
+import { installHostDialogAdvertiserWhenReady } from './host-dialog-advertiser.js';
+import { installHostDialogPortBridge } from './host-dialog-port.js';
+/**
+ * Pure guard predicate: should the dialog runtime activate in a renderer with
+ * this `argv` / `isMainFrame`? True only for the MAIN frame of a process whose
+ * argv carries the `'--dimina-host-dialog'` marker.
+ */
+export function shouldActivateHostDialogRuntime(argv, isMainFrame) {
+    return isMainFrame && argv.includes(HOST_DIALOG_RUNTIME_MARKER);
+}
+/**
+ * Run the guard; only when it passes, install the dual-axis size advertiser
+ * (`installHostDialogAdvertiserWhenReady`) and the narrow-channel page
+ * bridge (`installHostDialogPortBridge` — `window.diminaHostDialog` +
+ * the MessagePort handshake listener). Returns whether the runtime
+ * activated. A failed guard installs NOTHING (zero footprint in non-dialog
+ * windows and subframes: no advertiser, no bridge key, no IPC listener).
+ */
+export function activateHostDialogRuntime(env) {
+    if (!shouldActivateHostDialogRuntime(env.argv, env.isMainFrame))
+        return false;
+    installHostDialogAdvertiserWhenReady();
+    installHostDialogPortBridge();
+    return true;
+}
+//# sourceMappingURL=host-dialog-runtime.js.map

package/dist/preload/runtime/host-sidebar-advertiser.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Reverse size-advertiser preload for the host-controllable sidebar
+ * WebContentsView. Runs in that WCV's OWN renderer (the sidebar content's
+ * preload), measures the sidebar's intrinsic inline (width) extent and sends it
+ * to the main process. Main pushes the value back to the main-window renderer as
+ * `HostSidebarWidthChanged`, which resizes the sidebar placeholder, re-measures
+ * the forward anchor, and re-overlays this WCV — closing the dynamic-width loop
+ * (see `@dimina-kit/view-anchor` `createSizeAdvertiser`).
+ */
+/**
+ * Attach the advertiser to the sidebar content's shrink-to-fit root
+ * (`[data-host-sidebar-root]`), waiting for it if necessary — the root may be
+ * mounted asynchronously by a framework (e.g. React) rather than present in
+ * the initial HTML. That element MUST be shrink-to-fit on the inline axis —
+ * its width must reflect the content, not the host-applied view width, or the
+ * cross-process loop never converges (`createSizeAdvertiser`'s footgun).
+ */
+export declare function installHostSidebarAdvertiserWhenReady(): void;
+//# sourceMappingURL=host-sidebar-advertiser.d.ts.map

package/dist/preload/runtime/host-sidebar-advertiser.js

@@ -0,0 +1,35 @@
+/**
+ * Reverse size-advertiser preload for the host-controllable sidebar
+ * WebContentsView. Runs in that WCV's OWN renderer (the sidebar content's
+ * preload), measures the sidebar's intrinsic inline (width) extent and sends it
+ * to the main process. Main pushes the value back to the main-window renderer as
+ * `HostSidebarWidthChanged`, which resizes the sidebar placeholder, re-measures
+ * the forward anchor, and re-overlays this WCV — closing the dynamic-width loop
+ * (see `@dimina-kit/view-anchor` `createSizeAdvertiser`).
+ */
+import { ipcRenderer } from 'electron';
+import { createSizeAdvertiser } from '@dimina-kit/view-anchor';
+import { ViewChannel } from '../../shared/ipc-channels-overlays.js';
+import { whenSlotRootReady } from './wait-for-slot-root.js';
+/**
+ * Attach the advertiser to the sidebar content's shrink-to-fit root
+ * (`[data-host-sidebar-root]`), waiting for it if necessary — the root may be
+ * mounted asynchronously by a framework (e.g. React) rather than present in
+ * the initial HTML. That element MUST be shrink-to-fit on the inline axis —
+ * its width must reflect the content, not the host-applied view width, or the
+ * cross-process loop never converges (`createSizeAdvertiser`'s footgun).
+ */
+export function installHostSidebarAdvertiserWhenReady() {
+    whenSlotRootReady('[data-host-sidebar-root]', '[host-sidebar-advertiser] no `[data-host-sidebar-root]` element found — ' +
+        'not advertising a width yet. The sidebar content must wrap itself in a ' +
+        'shrink-to-fit `[data-host-sidebar-root]` element so its inline size is ' +
+        'the content width, not the host-given view size.', (root) => {
+        createSizeAdvertiser(root, {
+            axis: 'inline',
+            publish: (size) => {
+                ipcRenderer.send(ViewChannel.HostSidebarAdvertiseWidth, size);
+            },
+        });
+    });
+}
+//# sourceMappingURL=host-sidebar-advertiser.js.map

package/dist/preload/runtime/host-sidebar-port.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Preload side of the host-sidebar gated narrow channel.
+ *
+ * ── PUBLIC SURFACE EVOLUTION RULE ───────────────────────────────────────────
+ * `window.diminaHostSidebar` is a published page-facing API, typed by the
+ * exported `DiminaHostSidebarPageBridge` (src/main/runtime/miniapp-runtime.ts)
+ * — arbitrary host sidebar pages compile against it. Members may only be
+ * ADDED, never changed: any semantic change to an existing member (signature,
+ * return shape, queueing/throw behavior) ships under a NEW name instead.
+ * Exception: security fixes / compliance corrections may change existing
+ * member semantics, and MUST be called out in the release's version notes.
+ * Keep the exported bridge type in lockstep with what is exposed here.
+ *
+ * Receives the per-load MessagePort main transfers on `did-finish-load`
+ * (`ViewChannel.HostSidebarPort`, `event.ports[0]`) and bridges it to the page
+ * as `window.diminaHostSidebar` — EXACTLY `{ send, onMessage }`, functions
+ * only. The raw MessagePort never crosses into the main world: the page only
+ * ever talks through these two functions, so the `{ channel, payload }`
+ * envelope stays the single waist (same posture as the main side's
+ * host-sidebar-port-channel.ts).
+ *
+ * Ordering reality this module absorbs — identical to the toolbar's port
+ * bridge (see host-toolbar-port.ts for the full rationale): pre-handshake
+ * sends queue and bounded-drop, handlers register before the port exists and
+ * re-attach across same-load re-handshakes, inbound dispatch drops malformed
+ * envelopes without throwing.
+ *
+ * Shared implementation: see `host-slot-port-bridge.ts` (the toolbar/sidebar/
+ * dialog port bridges are otherwise identical; only the constants below
+ * differ).
+ */
+/**
+ * Cap on pre-handshake queued sends. Same rationale and value as
+ * `HOST_TOOLBAR_PENDING_LIMIT` — overflow drops the NEWEST envelope, one
+ * console.warn per load.
+ */
+export declare const HOST_SIDEBAR_PENDING_LIMIT = 128;
+/**
+ * Subscribe the handshake channel and expose the page bridge. Call ONLY from
+ * a passing sidebar-runtime guard (`activateHostSidebarRuntime`) — a failing
+ * guard must leave zero footprint (no bridge key, no IPC listener).
+ */
+export declare function installHostSidebarPortBridge(): void;
+//# sourceMappingURL=host-sidebar-port.d.ts.map

package/dist/preload/runtime/host-sidebar-port.js

@@ -0,0 +1,53 @@
+/**
+ * Preload side of the host-sidebar gated narrow channel.
+ *
+ * ── PUBLIC SURFACE EVOLUTION RULE ───────────────────────────────────────────
+ * `window.diminaHostSidebar` is a published page-facing API, typed by the
+ * exported `DiminaHostSidebarPageBridge` (src/main/runtime/miniapp-runtime.ts)
+ * — arbitrary host sidebar pages compile against it. Members may only be
+ * ADDED, never changed: any semantic change to an existing member (signature,
+ * return shape, queueing/throw behavior) ships under a NEW name instead.
+ * Exception: security fixes / compliance corrections may change existing
+ * member semantics, and MUST be called out in the release's version notes.
+ * Keep the exported bridge type in lockstep with what is exposed here.
+ *
+ * Receives the per-load MessagePort main transfers on `did-finish-load`
+ * (`ViewChannel.HostSidebarPort`, `event.ports[0]`) and bridges it to the page
+ * as `window.diminaHostSidebar` — EXACTLY `{ send, onMessage }`, functions
+ * only. The raw MessagePort never crosses into the main world: the page only
+ * ever talks through these two functions, so the `{ channel, payload }`
+ * envelope stays the single waist (same posture as the main side's
+ * host-sidebar-port-channel.ts).
+ *
+ * Ordering reality this module absorbs — identical to the toolbar's port
+ * bridge (see host-toolbar-port.ts for the full rationale): pre-handshake
+ * sends queue and bounded-drop, handlers register before the port exists and
+ * re-attach across same-load re-handshakes, inbound dispatch drops malformed
+ * envelopes without throwing.
+ *
+ * Shared implementation: see `host-slot-port-bridge.ts` (the toolbar/sidebar/
+ * dialog port bridges are otherwise identical; only the constants below
+ * differ).
+ */
+import { ViewChannel } from '../../shared/ipc-channels-overlays.js';
+import { createHostSlotPortBridge } from './host-slot-port-bridge.js';
+/**
+ * Cap on pre-handshake queued sends. Same rationale and value as
+ * `HOST_TOOLBAR_PENDING_LIMIT` — overflow drops the NEWEST envelope, one
+ * console.warn per load.
+ */
+export const HOST_SIDEBAR_PENDING_LIMIT = 128;
+/**
+ * Subscribe the handshake channel and expose the page bridge. Call ONLY from
+ * a passing sidebar-runtime guard (`activateHostSidebarRuntime`) — a failing
+ * guard must leave zero footprint (no bridge key, no IPC listener).
+ */
+export function installHostSidebarPortBridge() {
+    createHostSlotPortBridge({
+        bridgeKey: 'diminaHostSidebar',
+        channel: ViewChannel.HostSidebarPort,
+        pendingLimit: HOST_SIDEBAR_PENDING_LIMIT,
+        label: 'host-sidebar',
+    });
+}
+//# sourceMappingURL=host-sidebar-port.js.map

package/dist/preload/runtime/host-sidebar-runtime.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Session-resident host-sidebar framework runtime: GUARD + ACTIVATION.
+ *
+ * Same registration and guard shape as host-toolbar-runtime.ts (see that
+ * module for the full rationale): registered once per process on
+ * `session.defaultSession`, so it runs in EVERY defaultSession renderer;
+ * this guard keeps it inert everywhere except the host-sidebar WCV's main
+ * frame, identified by `HOST_SIDEBAR_RUNTIME_MARKER` in that process' argv.
+ */
+/**
+ * Pure guard predicate: should the sidebar runtime activate in a renderer with
+ * this `argv` / `isMainFrame`? True only for the MAIN frame of a process whose
+ * argv carries the `'--dimina-host-sidebar'` marker.
+ */
+export declare function shouldActivateHostSidebarRuntime(argv: readonly string[], isMainFrame: boolean): boolean;
+/**
+ * Run the guard; only when it passes, install the width advertiser
+ * (`installHostSidebarAdvertiserWhenReady`) and the narrow-channel page
+ * bridge (`installHostSidebarPortBridge` — `window.diminaHostSidebar` +
+ * the MessagePort handshake listener). Returns whether the runtime
+ * activated. A failed guard installs NOTHING (zero footprint in non-sidebar
+ * windows and subframes: no advertiser, no bridge key, no IPC listener).
+ */
+export declare function activateHostSidebarRuntime(env: {
+    argv: readonly string[];
+    isMainFrame: boolean;
+}): boolean;
+//# sourceMappingURL=host-sidebar-runtime.d.ts.map

package/dist/preload/runtime/host-sidebar-runtime.js

@@ -0,0 +1,36 @@
+/**
+ * Session-resident host-sidebar framework runtime: GUARD + ACTIVATION.
+ *
+ * Same registration and guard shape as host-toolbar-runtime.ts (see that
+ * module for the full rationale): registered once per process on
+ * `session.defaultSession`, so it runs in EVERY defaultSession renderer;
+ * this guard keeps it inert everywhere except the host-sidebar WCV's main
+ * frame, identified by `HOST_SIDEBAR_RUNTIME_MARKER` in that process' argv.
+ */
+import { HOST_SIDEBAR_RUNTIME_MARKER } from '../../shared/constants.js';
+import { installHostSidebarAdvertiserWhenReady } from './host-sidebar-advertiser.js';
+import { installHostSidebarPortBridge } from './host-sidebar-port.js';
+/**
+ * Pure guard predicate: should the sidebar runtime activate in a renderer with
+ * this `argv` / `isMainFrame`? True only for the MAIN frame of a process whose
+ * argv carries the `'--dimina-host-sidebar'` marker.
+ */
+export function shouldActivateHostSidebarRuntime(argv, isMainFrame) {
+    return isMainFrame && argv.includes(HOST_SIDEBAR_RUNTIME_MARKER);
+}
+/**
+ * Run the guard; only when it passes, install the width advertiser
+ * (`installHostSidebarAdvertiserWhenReady`) and the narrow-channel page
+ * bridge (`installHostSidebarPortBridge` — `window.diminaHostSidebar` +
+ * the MessagePort handshake listener). Returns whether the runtime
+ * activated. A failed guard installs NOTHING (zero footprint in non-sidebar
+ * windows and subframes: no advertiser, no bridge key, no IPC listener).
+ */
+export function activateHostSidebarRuntime(env) {
+    if (!shouldActivateHostSidebarRuntime(env.argv, env.isMainFrame))
+        return false;
+    installHostSidebarAdvertiserWhenReady();
+    installHostSidebarPortBridge();
+    return true;
+}
+//# sourceMappingURL=host-sidebar-runtime.js.map

package/dist/preload/runtime/host-slot-port-bridge.d.ts

@@ -0,0 +1,18 @@
+export interface HostSlotPortBridgeOptions {
+    /** contextBridge key the page-facing API is exposed under, e.g. 'diminaHostToolbar'. */
+    bridgeKey: string;
+    /** main → renderer per-load handshake channel, e.g. ViewChannel.HostToolbarPort. */
+    channel: string;
+    /** Cap on pre-handshake queued sends; overflow drops the NEWEST envelope. */
+    pendingLimit: number;
+    /** Slot label used in the overflow console.warn, e.g. 'host-toolbar'. */
+    label: string;
+}
+/**
+ * Subscribe the handshake channel and expose the page bridge. Call ONLY from
+ * a passing per-slot runtime guard — a failing guard must leave zero
+ * footprint (no bridge key, no IPC listener), so this factory itself does no
+ * guard checking; the caller decides whether to call it at all.
+ */
+export declare function createHostSlotPortBridge(opts: HostSlotPortBridgeOptions): void;
+//# sourceMappingURL=host-slot-port-bridge.d.ts.map

package/dist/preload/runtime/host-slot-port-bridge.js

@@ -0,0 +1,112 @@
+/**
+ * Shared implementation behind every host-slot page bridge (toolbar/sidebar/
+ * dialog): the MessagePort handshake, pending-queue-with-bounded-overflow,
+ * handler registry and `{ send, onMessage }` contextBridge exposure are
+ * IDENTICAL across slots — only the bridge key, handshake channel, queue cap
+ * and overflow-warning label differ. Each slot's own `host-*-port.ts` stays
+ * the frozen public surface (see its own "PUBLIC SURFACE EVOLUTION RULE"
+ * doc-comment) and calls this factory with its own constants; this module has
+ * no public-surface contract of its own.
+ */
+import { contextBridge, ipcRenderer } from 'electron';
+/**
+ * Subscribe the handshake channel and expose the page bridge. Call ONLY from
+ * a passing per-slot runtime guard — a failing guard must leave zero
+ * footprint (no bridge key, no IPC listener), so this factory itself does no
+ * guard checking; the caller decides whether to call it at all.
+ */
+export function createHostSlotPortBridge(opts) {
+    const { bridgeKey, channel, pendingLimit, label } = opts;
+    let activePort = null;
+    const pending = [];
+    // One overflow warning per load (this installer runs once per document) —
+    // a runaway page send-loop must not get per-drop console spam.
+    let warnedPendingOverflow = false;
+    const handlers = [];
+    // Entry-waist channel validation, parity with the main side's `onMessage`
+    // guard (same TypeError, message names `channel`). Runs BEFORE any state is
+    // touched (no queue slot, no registry entry), in both port states — a page
+    // author's typo throws at the call site instead of vanishing into main's
+    // silent inbound drop.
+    function assertValidChannel(method, ch) {
+        if (typeof ch !== 'string' || ch === '') {
+            throw new TypeError(`${bridgeKey}.${method}: channel must be a non-empty string`);
+        }
+    }
+    const dispatch = (data) => {
+        // Defensive symmetry with main: drop anything that is not an object
+        // envelope with a string channel — never throw in the dispatcher.
+        if (typeof data !== 'object' || data === null)
+            return;
+        const { channel: ch, payload } = data;
+        if (typeof ch !== 'string')
+            return;
+        for (const entry of [...handlers]) {
+            if (entry.channel === ch)
+                entry.handler(payload);
+        }
+    };
+    const onPortMessage = (event) => {
+        dispatch(event.data);
+    };
+    ipcRenderer.on(channel, (event) => {
+        const port = event.ports[0];
+        if (!port)
+            return;
+        // Same-load duplicate handshake: the LATER port wins. Main closed (or is
+        // about to close) its end of the old pair — detach and stop writing to it.
+        if (activePort) {
+            try {
+                activePort.removeEventListener('message', onPortMessage);
+                activePort.close();
+            }
+            catch {
+                /* already dead */
+            }
+        }
+        activePort = port;
+        // addEventListener (not onmessage) keeps the handler removable on
+        // re-handshake; it REQUIRES start() or inbound never delivers.
+        port.addEventListener('message', onPortMessage);
+        port.start();
+        // Flush sends issued before the port arrived, in order.
+        while (pending.length > 0) {
+            const envelope = pending.shift();
+            port.postMessage(envelope);
+        }
+    });
+    // EXACTLY { send, onMessage } — functions only; the port stays in the
+    // isolated world.
+    contextBridge.exposeInMainWorld(bridgeKey, {
+        send(ch, payload) {
+            assertValidChannel('send', ch);
+            const envelope = { channel: ch, payload };
+            if (activePort) {
+                activePort.postMessage(envelope);
+                return;
+            }
+            // Bounded queue: drop the NEWEST send on overflow (FIFO first-comers
+            // survive), warn once per load, never throw into page code.
+            if (pending.length >= pendingLimit) {
+                if (!warnedPendingOverflow) {
+                    warnedPendingOverflow = true;
+                    console.warn(`[dimina-devtools] ${label} pending queue full (${pendingLimit}); ` +
+                        'dropping further pre-handshake send() calls until the port arrives');
+                }
+                return;
+            }
+            pending.push(envelope);
+        },
+        onMessage(ch, handler) {
+            assertValidChannel('onMessage', ch);
+            const entry = { channel: ch, handler };
+            handlers.push(entry);
+            return () => {
+                const i = handlers.indexOf(entry);
+                if (i >= 0)
+                    handlers.splice(i, 1);
+            };
+        },
+    });
+}
+//# sourceMappingURL=host-slot-port-bridge.js.map

package/dist/preload/runtime/host-toolbar-advertiser.d.ts

@@ -9,19 +9,11 @@
  */
 /**
  * Attach the advertiser to the toolbar content's shrink-to-fit root
- * (`[data-host-toolbar-root]`). That element MUST be shrink-to-fit on the block
- * axis — its height must reflect the content, not the host-applied view height,
- * or the cross-process loop never converges (`createSizeAdvertiser`'s footgun).
- * If the element is missing we warn and no-op rather than measure `<body>`,
- * whose block size IS the view size and would advertise nonsense.
- *
- * Returns a disposer that tears the advertiser down.
- */
-export declare function installHostToolbarAdvertiser(): () => void;
-/**
- * Install once the DOM is ready (the root element must exist before we query).
- * Self-gating: if the document is already past `loading`, install synchronously;
- * otherwise wait for `DOMContentLoaded`.
+ * (`[data-host-toolbar-root]`), waiting for it if necessary — the root may be
+ * mounted asynchronously by a framework rather than present in the initial
+ * HTML. That element MUST be shrink-to-fit on the block axis — its height
+ * must reflect the content, not the host-applied view height, or the
+ * cross-process loop never converges (`createSizeAdvertiser`'s footgun).
  */
 export declare function installHostToolbarAdvertiserWhenReady(): void;
 //# sourceMappingURL=host-toolbar-advertiser.d.ts.map