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

package/dist/preload/index.d.ts

@@ -35,5 +35,7 @@ export { installCustomApisBridge } from './runtime/custom-apis.js';
 export type { DiminaCustomApisBridge } from './runtime/custom-apis.js';
 export { installNativeHostBridge } from './runtime/native-host.js';
 export type { DiminaNativeHostBridge } from './runtime/native-host.js';
+export { installClipboardBridge } from './runtime/clipboard.js';
+export type { DiminaClipboardBridge } from './runtime/clipboard.js';
 export { setupApiCompatHook } from './shared/api-compat.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/preload/index.js

@@ -36,5 +36,6 @@ export { installCustomApisBridge } from './runtime/custom-apis.js';
 // external/composed preloads aren't stranded once native-host becomes the sole
 // runtime. (Stage-0 prerequisite for decommissioning the default path.)
 export { installNativeHostBridge } from './runtime/native-host.js';
+export { installClipboardBridge } from './runtime/clipboard.js';
 export { setupApiCompatHook } from './shared/api-compat.js';
 //# sourceMappingURL=index.js.map

package/dist/preload/instrumentation/app-data.d.ts

@@ -1,6 +1,6 @@
 import type { MiniappSnapshotSource } from '../miniapp-snapshot/types.js';
-import { type AppDataSnapshot } from '../../shared/appdata-accumulator.js';
-export type { AppDataSnapshot } from '../../shared/appdata-accumulator.js';
+import { type AppDataSnapshot } from '@dimina-kit/inspect';
+export type { AppDataSnapshot } from '@dimina-kit/inspect';
 /**
  * The AppData snapshot data source.
  *

package/dist/preload/instrumentation/app-data.js

@@ -1,5 +1,5 @@
 import { clearAppDataSnapshot, setAppDataSnapshot, } from '../runtime/bridge.js';
-import { AppDataAccumulator, decodeOutgoingMessage, decodeWorkerMessage, } from '../../shared/appdata-accumulator.js';
+import { AppDataAccumulator, decodeOutgoingMessage, decodeWorkerMessage, } from '@dimina-kit/inspect';
 /**
  * The AppData snapshot data source.
  *

package/dist/preload/instrumentation/wxml.js

@@ -1,6 +1,6 @@
 import { clearWxmlSnapshot, setWxmlSnapshot, unhighlightElement, } from '../runtime/bridge.js';
 import { WXML_DEBOUNCE_MS, WXML_RETRY_INTERVAL_MS, WXML_RETRY_TIMEOUT_MS, NAVIGATION_POLL_INTERVAL_MS, NAVIGATION_TIMEOUT_MS, } from '../shared/constants.js';
-import { walkInstance } from './wxml-extract.js';
+import { walkInstance } from '@dimina-kit/inspect';
 import { getActivePageIframe } from '../shared/page-iframe.js';
 function getVueAppFromIframe(iframe) {
     try {

package/dist/preload/runtime/bridge.d.ts

@@ -1,7 +1,7 @@
 import type { ElementInspection } from '../../shared/ipc-channels.js';
-import { type WxmlNode } from '../shared/sid-registry.js';
-export type { WxmlNode } from '../shared/sid-registry.js';
-export { registerSyntheticSid } from '../shared/sid-registry.js';
+import { type WxmlNode } from '@dimina-kit/inspect';
+export type { WxmlNode } from '@dimina-kit/inspect';
+export { registerSyntheticSid } from '@dimina-kit/inspect';
 export interface Snapshot<T> {
     gen: number;
     ready: boolean;

package/dist/preload/runtime/bridge.js

@@ -1,7 +1,7 @@
 import { exposeOnMainWorld } from '../shared/expose.js';
 import { getActivePageIframe } from '../shared/page-iframe.js';
-import { findElementBySid } from '../shared/sid-registry.js';
-export { registerSyntheticSid } from '../shared/sid-registry.js';
+import { findElementBySid } from '@dimina-kit/inspect';
+export { registerSyntheticSid } from '@dimina-kit/inspect';
 const state = {
     appdata: { gen: 0, ready: true, data: {} },
     storage: { gen: 0, ready: false, namespace: null, data: {} },

package/dist/preload/runtime/clipboard.d.ts

@@ -0,0 +1,6 @@
+export interface DiminaClipboardBridge {
+    readText(): string;
+    writeText(text: string): void;
+}
+export declare function installClipboardBridge(): () => void;
+//# sourceMappingURL=clipboard.d.ts.map

package/dist/preload/runtime/clipboard.js

@@ -0,0 +1,12 @@
+import { clipboard } from 'electron';
+import { exposeOnMainWorld } from '../shared/expose.js';
+function buildBridge() {
+    return {
+        readText: () => clipboard.readText(),
+        writeText: (text) => clipboard.writeText(text),
+    };
+}
+export function installClipboardBridge() {
+    return exposeOnMainWorld('__diminaClipboard', buildBridge());
+}
+//# sourceMappingURL=clipboard.js.map

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