npm - @dimina-kit/devtools - Versions diffs - 0.4.0-dev.20260824071518 → 0.4.0-dev.20260828161241 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (160) hide show

package/dist/preload/runtime/host-toolbar-advertiser.js CHANGED Viewed

@@ -9,47 +9,27 @@
  */
 import { ipcRenderer } from 'electron';
 import { createSizeAdvertiser } from '@dimina-kit/view-anchor';
-import { ViewChannel } from '../../shared/ipc-channels.js';
+import { ViewChannel } from '../../shared/ipc-channels-overlays.js';
+import { whenSlotRootReady } from './wait-for-slot-root.js';
 /**
  * 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 function installHostToolbarAdvertiser() {
-    const root = document.querySelector('[data-host-toolbar-root]');
-    if (!root) {
-        console.warn('[host-toolbar-advertiser] no `[data-host-toolbar-root]` element found — ' +
-            'not advertising a height. The toolbar content must wrap itself in a ' +
-            'shrink-to-fit `[data-host-toolbar-root]` element so its block size is ' +
-            'the content height, not the host-given view size.');
-        return () => { };
-    }
-    const advertiser = createSizeAdvertiser(root, {
-        axis: 'block',
-        publish: (size) => {
-            ipcRenderer.send(ViewChannel.HostToolbarAdvertiseHeight, size);
-        },
-    });
-    return () => advertiser.dispose();
-}
-/**
- * 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 function installHostToolbarAdvertiserWhenReady() {
-    if (document.readyState === 'loading') {
-        document.addEventListener('DOMContentLoaded', () => {
-            installHostToolbarAdvertiser();
-        }, { once: true });
-    }
-    else {
-        installHostToolbarAdvertiser();
-    }
+    whenSlotRootReady('[data-host-toolbar-root]', '[host-toolbar-advertiser] no `[data-host-toolbar-root]` element found — ' +
+        'not advertising a height yet. The toolbar content must wrap itself in a ' +
+        'shrink-to-fit `[data-host-toolbar-root]` element so its block size is ' +
+        'the content height, not the host-given view size.', (root) => {
+        createSizeAdvertiser(root, {
+            axis: 'block',
+            publish: (size) => {
+                ipcRenderer.send(ViewChannel.HostToolbarAdvertiseHeight, size);
+            },
+        });
+    });
 }
 //# sourceMappingURL=host-toolbar-advertiser.js.map

package/dist/preload/runtime/host-toolbar-port.d.ts CHANGED Viewed

@@ -37,6 +37,10 @@
  *  - Inbound dispatch uses `addEventListener('message')` + `start()`
  *    (without `start()` a DOM MessagePort never delivers) and 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. 128 comfortably covers any sane toolbar
@@ -45,5 +49,10 @@
  * envelope (queued first-comers survive), one console.warn per load.
  */
 export declare const HOST_TOOLBAR_PENDING_LIMIT = 128;
+/**
+ * Subscribe the handshake channel and expose the page bridge. Call ONLY from
+ * a passing toolbar-runtime guard (`activateHostToolbarRuntime`) — a failing
+ * guard must leave zero footprint (no bridge key, no IPC listener).
+ */
 export declare function installHostToolbarPortBridge(): void;
 //# sourceMappingURL=host-toolbar-port.d.ts.map

package/dist/preload/runtime/host-toolbar-port.js CHANGED Viewed

@@ -37,10 +37,13 @@
  *  - Inbound dispatch uses `addEventListener('message')` + `start()`
  *    (without `start()` a DOM MessagePort never delivers) and 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 { contextBridge, ipcRenderer } from 'electron';
-import { ViewChannel } from '../../shared/ipc-channels.js';
-const BRIDGE_KEY = 'diminaHostToolbar';
+import { ViewChannel } from '../../shared/ipc-channels-overlays.js';
+import { createHostSlotPortBridge } from './host-slot-port-bridge.js';
 /**
  * Cap on pre-handshake queued sends. 128 comfortably covers any sane toolbar
  * boot sequence while bounding what a page whose handshake never completes
@@ -53,99 +56,12 @@ export const HOST_TOOLBAR_PENDING_LIMIT = 128;
  * a passing toolbar-runtime guard (`activateHostToolbarRuntime`) — a failing
  * guard must leave zero footprint (no bridge key, no IPC listener).
  */
-/**
- * Entry-waist channel validation, parity with the main side's
- * `hostToolbar.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, channel) {
-    if (typeof channel !== 'string' || channel === '') {
-        throw new TypeError(`diminaHostToolbar.${method}: channel must be a non-empty string`);
-    }
-}
 export function installHostToolbarPortBridge() {
-    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 = [];
-    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, payload } = data;
-        if (typeof channel !== 'string')
-            return;
-        for (const entry of [...handlers]) {
-            if (entry.channel === channel)
-                entry.handler(payload);
-        }
-    };
-    const onPortMessage = (event) => {
-        dispatch(event.data);
-    };
-    ipcRenderer.on(ViewChannel.HostToolbarPort, (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(BRIDGE_KEY, {
-        send(channel, payload) {
-            assertValidChannel('send', channel);
-            const envelope = { channel, 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 >= HOST_TOOLBAR_PENDING_LIMIT) {
-                if (!warnedPendingOverflow) {
-                    warnedPendingOverflow = true;
-                    console.warn(`[dimina-devtools] host-toolbar pending queue full (${HOST_TOOLBAR_PENDING_LIMIT}); ` +
-                        'dropping further pre-handshake send() calls until the port arrives');
-                }
-                return;
-            }
-            pending.push(envelope);
-        },
-        onMessage(channel, handler) {
-            assertValidChannel('onMessage', channel);
-            const entry = { channel, handler };
-            handlers.push(entry);
-            return () => {
-                const i = handlers.indexOf(entry);
-                if (i >= 0)
-                    handlers.splice(i, 1);
-            };
-        },
+    createHostSlotPortBridge({
+        bridgeKey: 'diminaHostToolbar',
+        channel: ViewChannel.HostToolbarPort,
+        pendingLimit: HOST_TOOLBAR_PENDING_LIMIT,
+        label: 'host-toolbar',
     });
 }
 //# sourceMappingURL=host-toolbar-port.js.map

package/dist/preload/runtime/wait-for-slot-root.d.ts ADDED Viewed

@@ -0,0 +1,20 @@
+/**
+ * Shared readiness wait for a host-slot content's shrink-to-fit measurement
+ * root (`[data-host-*-root]`). A one-shot `document.querySelector` at
+ * `DOMContentLoaded` time only works when the root is present in the initial
+ * HTML. Framework-rendered content (e.g. a React app) can mount its root
+ * asynchronously, after `DOMContentLoaded` has already fired — a one-shot
+ * check misses it permanently and the slot's width/height is never
+ * advertised. This keeps watching via `MutationObserver` instead of assuming
+ * a synchronous mount, without polling on a fixed delay.
+ *
+ * The "root is missing" warning exists for downstream authors who forgot the
+ * element entirely, so it must not fire on the healthy async-mount path — a
+ * warning printed on every normal load is noise that trains its readers to
+ * ignore it. It is therefore withheld until the document has finished loading
+ * (`window.load`, a real event rather than a guessed delay) with the root
+ * still absent; the observer stays armed either way, so a root that mounts
+ * even later is still picked up.
+ */
+export declare function whenSlotRootReady(selector: string, missingWarning: string, install: (root: HTMLElement) => void): void;
+//# sourceMappingURL=wait-for-slot-root.d.ts.map

package/dist/preload/runtime/wait-for-slot-root.js ADDED Viewed

@@ -0,0 +1,52 @@
+/**
+ * Shared readiness wait for a host-slot content's shrink-to-fit measurement
+ * root (`[data-host-*-root]`). A one-shot `document.querySelector` at
+ * `DOMContentLoaded` time only works when the root is present in the initial
+ * HTML. Framework-rendered content (e.g. a React app) can mount its root
+ * asynchronously, after `DOMContentLoaded` has already fired — a one-shot
+ * check misses it permanently and the slot's width/height is never
+ * advertised. This keeps watching via `MutationObserver` instead of assuming
+ * a synchronous mount, without polling on a fixed delay.
+ *
+ * The "root is missing" warning exists for downstream authors who forgot the
+ * element entirely, so it must not fire on the healthy async-mount path — a
+ * warning printed on every normal load is noise that trains its readers to
+ * ignore it. It is therefore withheld until the document has finished loading
+ * (`window.load`, a real event rather than a guessed delay) with the root
+ * still absent; the observer stays armed either way, so a root that mounts
+ * even later is still picked up.
+ */
+export function whenSlotRootReady(selector, missingWarning, install) {
+    function attempt() {
+        const root = document.querySelector(selector);
+        if (root) {
+            install(root);
+            return;
+        }
+        let installed = false;
+        const observer = new MutationObserver(() => {
+            const lateRoot = document.querySelector(selector);
+            if (!lateRoot)
+                return;
+            observer.disconnect();
+            installed = true;
+            install(lateRoot);
+        });
+        observer.observe(document.documentElement, { childList: true, subtree: true });
+        const warnIfStillMissing = () => {
+            if (!installed)
+                console.warn(missingWarning);
+        };
+        if (document.readyState === 'complete')
+            warnIfStillMissing();
+        else
+            window.addEventListener('load', warnIfStillMissing, { once: true });
+    }
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', attempt, { once: true });
+    }
+    else {
+        attempt();
+    }
+}
+//# sourceMappingURL=wait-for-slot-root.js.map

package/dist/preload/windows/host-dialog-runtime.cjs ADDED Viewed

@@ -0,0 +1,353 @@
+"use strict";
+// src/shared/constants.ts
+var HOST_DIALOG_RUNTIME_MARKER = "--dimina-host-dialog";
+// src/preload/runtime/host-dialog-advertiser.ts
+var import_electron = require("electron");
+// ../view-anchor/src/measure-loop.ts
+function createMeasureLoop(cfg) {
+  const { produce, same, sink } = cfg;
+  let rafId = null;
+  let active = false;
+  let disposed = false;
+  let last = null;
+  const cancel = () => {
+    if (rafId !== null) {
+      cancelAnimationFrame(rafId);
+      rafId = null;
+    }
+  };
+  return {
+    schedule() {
+      if (disposed || !active || rafId !== null) return;
+      rafId = requestAnimationFrame(() => {
+        rafId = null;
+        if (disposed || !active) return;
+        const value = produce();
+        if (value === null) return;
+        if (last !== null && same(value, last)) return;
+        last = value;
+        sink(value);
+      });
+    },
+    emitNow(value) {
+      if (disposed) return;
+      last = value;
+      sink(value);
+    },
+    setActive(on) {
+      active = on;
+    },
+    cancel,
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      cancel();
+    }
+  };
+}
+// ../view-anchor/src/size-advertiser.ts
+function createSizeAdvertiser(target, opts) {
+  const axis = opts.axis;
+  let publish = opts.publish;
+  let observer = null;
+  let disposed = false;
+  let latest = null;
+  const produce = () => {
+    if (!latest) return null;
+    const raw = axis === "block" ? latest.blockSize : latest.inlineSize;
+    if (!Number.isFinite(raw)) return null;
+    return { axis, extent: Math.max(0, Math.round(raw)) };
+  };
+  const loop = createMeasureLoop({
+    produce,
+    same: (a, b) => a.extent === b.extent,
+    // axis is constant
+    sink: (size) => publish(size)
+  });
+  const onResize = (entries) => {
+    const entry = entries[entries.length - 1];
+    if (entry) {
+      latest = entry.borderBoxSize?.[0] ?? entry.contentBoxSize?.[0] ?? latest;
+    }
+    loop.schedule();
+  };
+  const doc = target.ownerDocument;
+  if (target === doc.body || target === doc.documentElement) {
+    console.warn(
+      `[view-anchor] size-advertiser: <${target === doc.body ? "body" : "html"}>'s ${axis} size is the host-given view size, not the content size \u2014 the advertiser will never shrink to content. Measure a shrink-to-fit wrapper. See bidirectional-design.md's single-axis-ownership section.`
+    );
+  }
+  loop.setActive(true);
+  observer = new ResizeObserver(onResize);
+  observer.observe(target);
+  return {
+    update(nextPublish) {
+      if (disposed) return;
+      publish = nextPublish;
+      const cur = produce();
+      if (cur) loop.emitNow(cur);
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      loop.cancel();
+      if (observer) {
+        observer.disconnect();
+        observer = null;
+      }
+      loop.dispose();
+    }
+  };
+}
+// src/shared/ipc-channels-overlays.ts
+var ViewChannel = {
+  /**
+   * Reverse size-advertiser: the host-toolbar WCV's OWN renderer advertises its
+   * intrinsic content height so main reserves exactly that much. Payload
+   * `{ axis: 'block', extent }`. fire-and-forget (send), NOT invoke.
+   */
+  HostToolbarAdvertiseHeight: "view:host-toolbar:advertise-height",
+  /**
+   * main → host-toolbar WCV renderer: per-load MessagePort handshake for the
+   * gated narrow channel. On every toolbar `did-finish-load` main creates a
+   * `MessageChannelMain` and transfers port2 here
+   * (`wc.postMessage(HostToolbarPort, null, [port2])`); the session-resident
+   * toolbar runtime preload receives it via `event.ports[0]` and bridges it to
+   * the page as `window.diminaHostToolbar`. Envelope both directions:
+   * `{ channel: string, payload: unknown }`.
+   */
+  HostToolbarPort: "view:host-toolbar:port",
+  /**
+   * main → main-window renderer: push the reserved host-toolbar height so the
+   * renderer placeholder div resizes (closing the dynamic-height loop).
+   */
+  HostToolbarHeightChanged: "view:host-toolbar:height-changed",
+  /**
+   * main ← main-window renderer (invoke): pull the last NOTIFIED toolbar
+   * height retained in main. Mount-time replay companion to
+   * `HostToolbarHeightChanged`: the push listener mounts with the project
+   * view and the toolbar's size-advertiser deduplicates (never re-reports),
+   * so a height pushed while no project view was mounted would otherwise be
+   * lost forever (cold start on the project list races it; close-project →
+   * reopen hits it deterministically). No payload; resolves a number.
+   */
+  HostToolbarGetHeight: "view:host-toolbar:get-height",
+  /**
+   * Reverse size-advertiser for the host-sidebar WCV, mirroring
+   * `HostToolbarAdvertiseHeight` on the inline (width) axis instead of block.
+   * Payload `{ axis: 'inline', extent }`. fire-and-forget (send), NOT invoke.
+   */
+  HostSidebarAdvertiseWidth: "view:host-sidebar:advertise-width",
+  /**
+   * main → host-sidebar WCV renderer: per-load MessagePort handshake, same
+   * contract as `HostToolbarPort` (see that entry).
+   */
+  HostSidebarPort: "view:host-sidebar:port",
+  /**
+   * main → main-window renderer: push the reserved host-sidebar width so the
+   * renderer placeholder div resizes, mirroring `HostToolbarHeightChanged`.
+   */
+  HostSidebarWidthChanged: "view:host-sidebar:width-changed",
+  /**
+   * main ← main-window renderer (invoke): pull the last NOTIFIED sidebar
+   * width, mirroring `HostToolbarGetHeight`'s mount-time replay role.
+   */
+  HostSidebarGetWidth: "view:host-sidebar:get-width",
+  /**
+   * main → main-window renderer: push the project category (`Project.type`)
+   * selected in the host-sidebar's content — devtools' own default icon rail,
+   * or any downstream replacement that sends on the same channel. No
+   * pull/replay companion like `HostSidebarGetWidth`: the default category is
+   * a stable initial value regardless of load-order, and nothing is ever sent
+   * before the main-window renderer (and thus `ProjectListScreen`) is already
+   * mounted.
+   */
+  HostSidebarCategorySelected: "view:host-sidebar:category-selected",
+  /**
+   * Reverse size-advertiser for the host-dialog WCV. Unlike the toolbar/sidebar
+   * (single-axis, `setBaseDesired`-placed strips), the dialog is a BOTH-AXES
+   * overlay positioned by `setOverlayDesired` — main centers it in the main
+   * window once it knows both dimensions. One channel carries either axis'
+   * report (`{ axis: 'block' | 'inline', extent }`); the dialog's own content
+   * advertises both from the same root (see `host-dialog-advertiser.ts`).
+   * fire-and-forget (send), NOT invoke.
+   *
+   * No `HostDialogSizeChanged` / `HostDialogGetSize` counterparts: those exist
+   * for toolbar/sidebar so a renderer-owned PLACEHOLDER can replay a size it
+   * missed. The dialog has no such placeholder — it is a main-driven overlay
+   * shown/hidden on demand (`hostDialog.show()`/`hide()`), so there is nothing
+   * in the renderer to replay a size into.
+   */
+  HostDialogAdvertiseSize: "view:host-dialog:advertise-size",
+  /**
+   * main → host-dialog WCV renderer: per-load MessagePort handshake, same
+   * contract as `HostToolbarPort` (see that entry).
+   */
+  HostDialogPort: "view:host-dialog:port",
+  /**
+   * Renderer → main: the window-level placement snapshot (one monotonic epoch
+   * per commit tick, one generation per renderer lifetime) that drives the view
+   * reconciler. The single source of truth for every managed native view's
+   * bounds/visibility/z-order — supersedes the per-view bounds channels above.
+   * invoke.
+   */
+  PlacementSnapshot: "view:placement-snapshot",
+  /**
+   * main ← main-window renderer (invoke): allocate a fresh placement
+   * generation seed for this renderer bootstrap. See
+   * renderer-placement-generation.ts for why the seed comes from main
+   * (a wall-clock `Date.now()` seed is not guaranteed to exceed main's
+   * still-standing high-water mark across two reloads that happen faster
+   * than the clock's resolution). No payload; resolves a number.
+   */
+  AllocatePlacementGeneration: "view:allocate-placement-generation"
+};
+// src/preload/runtime/wait-for-slot-root.ts
+function whenSlotRootReady(selector, missingWarning, install) {
+  function attempt() {
+    const root = document.querySelector(selector);
+    if (root) {
+      install(root);
+      return;
+    }
+    let installed = false;
+    const observer = new MutationObserver(() => {
+      const lateRoot = document.querySelector(selector);
+      if (!lateRoot) return;
+      observer.disconnect();
+      installed = true;
+      install(lateRoot);
+    });
+    observer.observe(document.documentElement, { childList: true, subtree: true });
+    const warnIfStillMissing = () => {
+      if (!installed) console.warn(missingWarning);
+    };
+    if (document.readyState === "complete") warnIfStillMissing();
+    else window.addEventListener("load", warnIfStillMissing, { once: true });
+  }
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", attempt, { once: true });
+  } else {
+    attempt();
+  }
+}
+// src/preload/runtime/host-dialog-advertiser.ts
+function installHostDialogAdvertiserWhenReady() {
+  whenSlotRootReady(
+    "[data-host-dialog-root]",
+    "[host-dialog-advertiser] no `[data-host-dialog-root]` element found \u2014 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) => {
+        import_electron.ipcRenderer.send(ViewChannel.HostDialogAdvertiseSize, size);
+      };
+      createSizeAdvertiser(root, { axis: "block", publish });
+      createSizeAdvertiser(root, { axis: "inline", publish });
+    }
+  );
+}
+// src/preload/runtime/host-slot-port-bridge.ts
+var import_electron2 = require("electron");
+function createHostSlotPortBridge(opts) {
+  const { bridgeKey, channel, pendingLimit, label } = opts;
+  let activePort = null;
+  const pending = [];
+  let warnedPendingOverflow = false;
+  const handlers = [];
+  function assertValidChannel(method, ch) {
+    if (typeof ch !== "string" || ch === "") {
+      throw new TypeError(`${bridgeKey}.${method}: channel must be a non-empty string`);
+    }
+  }
+  const dispatch = (data) => {
+    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);
+  };
+  import_electron2.ipcRenderer.on(channel, (event) => {
+    const port = event.ports[0];
+    if (!port) return;
+    if (activePort) {
+      try {
+        activePort.removeEventListener("message", onPortMessage);
+        activePort.close();
+      } catch {
+      }
+    }
+    activePort = port;
+    port.addEventListener("message", onPortMessage);
+    port.start();
+    while (pending.length > 0) {
+      const envelope = pending.shift();
+      port.postMessage(envelope);
+    }
+  });
+  import_electron2.contextBridge.exposeInMainWorld(bridgeKey, {
+    send(ch, payload) {
+      assertValidChannel("send", ch);
+      const envelope = { channel: ch, payload };
+      if (activePort) {
+        activePort.postMessage(envelope);
+        return;
+      }
+      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);
+      };
+    }
+  });
+}
+// src/preload/runtime/host-dialog-port.ts
+var HOST_DIALOG_PENDING_LIMIT = 128;
+function installHostDialogPortBridge() {
+  createHostSlotPortBridge({
+    bridgeKey: "diminaHostDialog",
+    channel: ViewChannel.HostDialogPort,
+    pendingLimit: HOST_DIALOG_PENDING_LIMIT,
+    label: "host-dialog"
+  });
+}
+// src/preload/runtime/host-dialog-runtime.ts
+function shouldActivateHostDialogRuntime(argv, isMainFrame) {
+  return isMainFrame && argv.includes(HOST_DIALOG_RUNTIME_MARKER);
+}
+function activateHostDialogRuntime(env) {
+  if (!shouldActivateHostDialogRuntime(env.argv, env.isMainFrame)) return false;
+  installHostDialogAdvertiserWhenReady();
+  installHostDialogPortBridge();
+  return true;
+}
+// src/preload/windows/host-dialog-runtime.ts
+activateHostDialogRuntime({ argv: process.argv, isMainFrame: process.isMainFrame });
+//# sourceMappingURL=host-dialog-runtime.cjs.map