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

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

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

@@ -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

@@ -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

@@ -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/native-host.d.ts

@@ -3,10 +3,24 @@ import type { ActivePagePayload, ApiResponsePayload, NavCallbackPayload, PageLif
 export interface RenderHostUrlOptions {
     bridgeId: string;
     appId: string;
+    /** The page's resource root inside the mini-app package (e.g. `'main'`), from `SpawnResult.root`. */
+    root: string;
     pagePath: string;
     /** Whether this page is a tabBar page. Surfaced on the URL so main can pick
      *  the bottom safe-area policy at `did-attach-webview` (services/safe-area). */
     isTab?: boolean;
+    /** The page's resolved `navigationStyle` (page ∪ app-level). Surfaced on the
+     *  URL as `navStyle` so main can pick the TOP safe-area policy at
+     *  `did-attach-webview` (services/safe-area). */
+    navigationStyle?: 'default' | 'custom';
+    /** The page's resolved `window.backgroundColor` (page ∪ app-level, already
+     *  defaulted — see `pageBackgroundColor` in page-stack-controller.ts).
+     *  Surfaced on the URL as `bgColor`: render-host/preload.cjs reads it and
+     *  primes the guest's own document background before the page's own CSS
+     *  loads. `WebContents` (the `<webview>` guest) has no `setBackgroundColor`,
+     *  so main never consumes this — DeviceShell separately primes the host
+     *  `<webview>` element's own CSS background from the same source. */
+    backgroundColor?: string;
 }
 export interface DiminaNativeHostBridge {
     enabled: boolean;

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

@@ -1,5 +1,6 @@
 import { ipcRenderer } from 'electron';
 import { BRIDGE_CHANNELS as C } from '../../shared/bridge-channels.js';
+import { buildRenderHostDocumentUrl } from '../../shared/dmb-resource-url.js';
 import { exposeOnMainWorld } from '../shared/expose.js';
 /**
  * Ask the main process (synchronously, at install time) whether native-host is
@@ -50,14 +51,10 @@ function buildBridge(cfg) {
             ipcRenderer.send(C.PAGE_STACK, payload);
         },
         createRenderHostUrl(opts) {
-            // `URL` + `URLSearchParams` are web globals — no node:url needed.
-            const url = new URL(cfg.renderHostHtmlUrl);
-            url.searchParams.set('bridgeId', opts.bridgeId);
-            url.searchParams.set('appId', opts.appId);
-            url.searchParams.set('pagePath', opts.pagePath);
-            if (opts.isTab)
-                url.searchParams.set('isTab', '1');
-            return url.toString();
+            // Same-origin document on `dmb-resource://<bridgeId>/<appId>/<root>/<page directory>/__frame__.html`
+            // (path depth tracks the page's package directory depth) so relative
+            // package image paths resolve against the resource server, not file:// asar.
+            return buildRenderHostDocumentUrl(opts);
         },
         renderPreloadUrl: cfg.renderPreloadUrl,
         device: cfg.device,

package/dist/preload/runtime/node-bindings.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Publishes real Node built-ins into the simulator document's shared JS
+ * world (see shared/node-bindings for the consumer-side contract).
+ *
+ * The simulator WebContentsView runs nodeIntegration:false + sandbox:false +
+ * contextIsolation:false: page scripts cannot require Node modules and the
+ * vite bundle stubs `node:*` imports, but this preload shares the page's JS
+ * world and has full Node access. The FileSystemManager backends and the
+ * vpath resolver in the simulator bundle read these bindings.
+ *
+ * Trust boundary: this preload is assigned ONLY to the simulator top document
+ * (devtools' own code) via webPreferences.preload — miniapp render guests and
+ * the service host carry their own dedicated preloads, and no preload is
+ * session-registered (`setPreloads` is unused repo-wide), so mini-program
+ * code never sees these bindings.
+ */
+export declare function installNodeBindings(): void;
+//# sourceMappingURL=node-bindings.d.ts.map

package/dist/preload/runtime/node-bindings.js

@@ -0,0 +1,44 @@
+/**
+ * Publishes real Node built-ins into the simulator document's shared JS
+ * world (see shared/node-bindings for the consumer-side contract).
+ *
+ * The simulator WebContentsView runs nodeIntegration:false + sandbox:false +
+ * contextIsolation:false: page scripts cannot require Node modules and the
+ * vite bundle stubs `node:*` imports, but this preload shares the page's JS
+ * world and has full Node access. The FileSystemManager backends and the
+ * vpath resolver in the simulator bundle read these bindings.
+ *
+ * Trust boundary: this preload is assigned ONLY to the simulator top document
+ * (devtools' own code) via webPreferences.preload — miniapp render guests and
+ * the service host carry their own dedicated preloads, and no preload is
+ * session-registered (`setPreloads` is unused repo-wide), so mini-program
+ * code never sees these bindings.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import buffer from 'node:buffer';
+import { NODE_BINDINGS_GLOBAL } from '../../shared/node-bindings.js';
+export function installNodeBindings() {
+    // contextIsolation:false means page scripts share this world: freeze the
+    // bag (no member swap) and publish it non-writable AND non-configurable —
+    // writable:false alone still leaves `delete` and a defineProperty
+    // redefinition open to any same-world script, so the full lock needs
+    // configurable:false too. A compromised page script then cannot
+    // substitute a spoofed `fs` for the vpath resolver / FSM backends to
+    // trust by any route.
+    const existing = Object.getOwnPropertyDescriptor(globalThis, NODE_BINDINGS_GLOBAL);
+    if (existing && !existing.configurable) {
+        // Already locked (redefining a non-configurable property throws).
+        return;
+    }
+    const bindings = Object.freeze({ fs, os, path, crypto, buffer });
+    Object.defineProperty(globalThis, NODE_BINDINGS_GLOBAL, {
+        value: bindings,
+        writable: false,
+        configurable: false,
+        enumerable: true,
+    });
+}
+//# sourceMappingURL=node-bindings.js.map

package/dist/preload/runtime/temp-files.js

@@ -19,8 +19,15 @@ export function installTempFileBridge() {
                 });
             })
                 .catch(() => {
-                // best effort: blob read failures cannot be surfaced through the
-                // sink contract (`write` is sync void), so we swallow them.
+                // 旧的同步创建入口只能 best effort；要求立即可读的调用走 writeAndWait。
+            });
+        },
+        async writeAndWait(path, blob) {
+            const bytes = await blob.arrayBuffer();
+            await ipcRenderer.invoke('simulator:temp-file:write-confirmed', {
+                path,
+                mime: blob.type,
+                bytes,
             });
         },
         revoke(path) {

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

@@ -0,0 +1,23 @@
+/**
+ * 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. Two conditions gate it, both signals rather than guessed delays:
+ * the document must be one the host actually loaded content into (not the
+ * view's own blank document), and it must have finished loading AND run out of
+ * pending work (`window.load`, then an idle callback — a framework's first
+ * commit is normal-priority work, so it always lands before idle). 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

@@ -0,0 +1,80 @@
+/**
+ * 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. Two conditions gate it, both signals rather than guessed delays:
+ * the document must be one the host actually loaded content into (not the
+ * view's own blank document), and it must have finished loading AND run out of
+ * pending work (`window.load`, then an idle callback — a framework's first
+ * commit is normal-priority work, so it always lands before idle). 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() {
+        // The slot's WebContentsView holds its own empty document until the host
+        // loads content into it, and this preload runs there too. That document
+        // has no author: a missing root in it is not a mistake anyone made, and
+        // warning about it fires on every app start. The observer below still gets
+        // armed, so content that does arrive is picked up.
+        const authored = location.href !== 'about:blank' && location.href !== '';
+        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 });
+        // Re-queries rather than trusting `installed`: the observer delivers on a
+        // microtask, so a root that is already in the DOM may not have been
+        // installed yet — it is present either way, which is what the warning is
+        // about.
+        const warnIfStillMissing = () => {
+            if (installed || !authored || document.querySelector(selector))
+                return;
+            console.warn(missingWarning);
+        };
+        // `load` alone is too early a verdict: a concurrent React root commits its
+        // first render on a scheduler task that can land after it, and the warning
+        // would then race the healthy mount it is supposed to ignore. Idle
+        // callbacks run only once the main thread has no pending work of that
+        // kind, so a root still absent then is genuinely absent. The timeout is
+        // the cap for a page that never goes idle, not the mechanism.
+        const decide = () => {
+            const idle = globalThis
+                .requestIdleCallback;
+            if (typeof idle === 'function')
+                idle(warnIfStillMissing, { timeout: 5_000 });
+            else
+                warnIfStillMissing();
+        };
+        if (document.readyState === 'complete')
+            decide();
+        else
+            window.addEventListener('load', decide, { once: true });
+    }
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', attempt, { once: true });
+    }
+    else {
+        attempt();
+    }
+}
+//# sourceMappingURL=wait-for-slot-root.js.map