@dimina-kit/devtools 0.3.2-dev.20260601115343 → 0.3.2-dev.20260610114009

package/dist/shared/appdata-accumulator.js

@@ -0,0 +1,213 @@
+/**
+ * Framework-agnostic AppData accumulator.
+ *
+ * The dimina runtime emits two service→render messages relevant to the AppData
+ * panel, identical in shape on BOTH container paths:
+ *   • update batches `{type:'ub', body:{bridgeId, updates:[{moduleId,data}]}}`
+ *     — each `data` is a partial setData patch.
+ *   • instance init: `type === 'page_*'`, body `{bridgeId, path, data}` with the
+ *     COMPLETE initial state.
+ *
+ * Default (dimina-fe) path: the simulator preload sniffs these as Worker
+ * `message` events (app-data.ts). Native-host path: they flow service→render
+ * through bridge-router (SERVICE_PUBLISH). Both feed this one accumulator so the
+ * decode/merge/page-only/R6 policy can't drift between modes.
+ */
+/**
+ * Decode a service→render message into AppData entries, or null when it is not
+ * AppData-relevant. Policy: surface PAGE entries only — component entries are
+ * dropped (they sometimes flow on a bridge id distinct from their owning page's
+ * and never receive pageUnload, which would manifest as ghost tabs).
+ */
+export function decodeWorkerMessage(message) {
+    let payload = message;
+    if (typeof payload === 'string') {
+        try {
+            payload = JSON.parse(payload);
+        }
+        catch {
+            return null;
+        }
+    }
+    if (!payload || typeof payload !== 'object')
+        return null;
+    const record = payload;
+    if (record.type === 'ub') {
+        const body = record.body;
+        if (!body || typeof body !== 'object')
+            return null;
+        if (typeof body.bridgeId !== 'string' || !Array.isArray(body.updates))
+            return null;
+        const out = [];
+        for (const u of body.updates) {
+            if (!u || typeof u.moduleId !== 'string')
+                continue;
+            if (!u.moduleId.startsWith('page_'))
+                continue;
+            out.push({ mode: 'patch', bridgeId: body.bridgeId, moduleId: u.moduleId, data: u.data });
+        }
+        return out.length > 0 ? out : null;
+    }
+    if (typeof record.type === 'string' && record.type.startsWith('page_')) {
+        const body = record.body;
+        if (!body || typeof body !== 'object')
+            return null;
+        if (typeof body.bridgeId !== 'string' || typeof body.path !== 'string')
+            return null;
+        if (!body.data || typeof body.data !== 'object')
+            return null;
+        return [{
+                mode: 'init',
+                bridgeId: body.bridgeId,
+                moduleId: record.type,
+                componentPath: body.path,
+                data: body.data,
+            }];
+    }
+    return null;
+}
+/** main→worker direction: container signals page teardown so cache can evict. */
+export function decodeOutgoingMessage(message) {
+    let payload = message;
+    if (typeof payload === 'string') {
+        try {
+            payload = JSON.parse(payload);
+        }
+        catch {
+            return null;
+        }
+    }
+    if (!payload || typeof payload !== 'object')
+        return null;
+    const r = payload;
+    if (typeof r.type !== 'string')
+        return null;
+    return {
+        type: r.type,
+        bridgeId: typeof r.body?.bridgeId === 'string' ? r.body.bridgeId : undefined,
+    };
+}
+/** Convert a decoded entry to the normalized accumulator input. */
+export function decodedToInput(entry) {
+    const input = {
+        bridgeId: entry.bridgeId,
+        moduleId: entry.moduleId,
+        data: entry.data,
+        mode: entry.mode,
+    };
+    if (entry.mode === 'init')
+        input.componentPath = entry.componentPath;
+    return input;
+}
+/**
+ * Cumulative per-(bridgeId, moduleId) setData state. Pure data structure — no
+ * Worker / IPC / DOM. Callers own transport (publish/emit) and the automation
+ * mirror.
+ */
+export class AppDataAccumulator {
+    cache = new Map();
+    // Bridges in insertion order — drives the `bridges` array (stable tab order).
+    bridgeOrder = [];
+    // Page path per bridge: set from `page_*` init's body.path (the page route).
+    bridgePagePath = new Map();
+    recordBridge(bridgeId) {
+        if (!this.bridgeOrder.includes(bridgeId))
+            this.bridgeOrder.push(bridgeId);
+    }
+    /**
+     * Apply one entry. Returns true if it was accepted (a mutation worth
+     * republishing), false if dropped (missing ids, or the R6 gate).
+     */
+    apply(input) {
+        if (!input.bridgeId || !input.moduleId)
+            return false;
+        // R6: drop ub patches whose bridge has never been initialised. dimina
+        // dispatches pageUnload → onUnload, whose setData produces a late `ub`
+        // arriving AFTER clearBridge; without this gate it would resurrect the
+        // unloaded bridge as a ghost tab.
+        if (input.mode !== 'init' && !this.bridgePagePath.has(input.bridgeId))
+            return false;
+        const key = `${input.bridgeId}/${input.moduleId}`;
+        const prev = this.cache.get(key);
+        const incoming = input.data && typeof input.data === 'object'
+            ? input.data
+            : {};
+        // init = full-state replace; patch = merge into previous (setData semantics)
+        const merged = input.mode === 'init'
+            ? { ...incoming }
+            : { ...(prev?.data ?? {}), ...incoming };
+        const componentPath = input.componentPath ?? prev?.componentPath;
+        const next = componentPath !== undefined
+            ? { componentPath, data: merged }
+            : { data: merged };
+        this.cache.set(key, next);
+        this.recordBridge(input.bridgeId);
+        if (input.mode === 'init' && input.moduleId.startsWith('page_') && input.componentPath) {
+            this.bridgePagePath.set(input.bridgeId, input.componentPath);
+        }
+        return true;
+    }
+    /** Evict every entry for a bridge (page teardown). */
+    clearBridge(bridgeId) {
+        const prefix = `${bridgeId}/`;
+        for (const key of [...this.cache.keys()]) {
+            if (key.startsWith(prefix))
+                this.cache.delete(key);
+        }
+        const idx = this.bridgeOrder.indexOf(bridgeId);
+        if (idx >= 0)
+            this.bridgeOrder.splice(idx, 1);
+        this.bridgePagePath.delete(bridgeId);
+    }
+    /** The full cumulative snapshot for the panel. */
+    snapshot() {
+        const bridges = [];
+        for (const id of this.bridgeOrder) {
+            bridges.push({ id, pagePath: this.bridgePagePath.get(id) ?? null });
+        }
+        const entries = {};
+        for (const [key, entry] of this.cache) {
+            const slash = key.indexOf('/');
+            if (slash < 0)
+                continue;
+            const bridgeId = key.slice(0, slash);
+            const moduleId = key.slice(slash + 1);
+            if (!entries[bridgeId])
+                entries[bridgeId] = {};
+            const displayKey = entry.componentPath ?? moduleId;
+            entries[bridgeId][displayKey] = entry.data;
+        }
+        return { bridges, entries };
+    }
+    /**
+     * The current reactive page state for a bridge: shallow-merge of `entry.data`
+     * across every cache entry whose key starts with `${bridgeId}/`, in insertion
+     * order (later entries win on key conflicts). `{}` when no entries match
+     * (unknown bridge / after clearBridge). Pure, no side effects.
+     */
+    pageData(bridgeId) {
+        const merged = {};
+        for (const [key, entry] of this.cache) {
+            const slash = key.indexOf('/');
+            if (slash < 0)
+                continue;
+            if (key.slice(0, slash) !== bridgeId)
+                continue;
+            Object.assign(merged, entry.data);
+        }
+        return merged;
+    }
+    /** Flat `key → data` map for the `__simulatorData.getAppdata()` mirror. */
+    flat() {
+        const data = {};
+        for (const [key, entry] of this.cache)
+            data[key] = entry.data;
+        return data;
+    }
+    clear() {
+        this.cache.clear();
+        this.bridgeOrder.length = 0;
+        this.bridgePagePath.clear();
+    }
+}
+//# sourceMappingURL=appdata-accumulator.js.map

package/dist/shared/bridge-channels.d.ts

@@ -0,0 +1,378 @@
+import type { NativeDeviceInfo } from './ipc-channels.js';
+export declare const BRIDGE_CHANNELS: {
+    readonly SPAWN: "dmb:spawn";
+    readonly DISPOSE: "dmb:dispose";
+    readonly PAGE_OPEN: "dmb:page:open";
+    readonly PAGE_CLOSE: "dmb:page:close";
+    readonly PAGE_LIFECYCLE: "dmb:page:lifecycle";
+    readonly NAV_CALLBACK: "dmb:nav:callback";
+    readonly SERVICE_INVOKE: "dmb:service:invoke";
+    readonly SERVICE_PUBLISH: "dmb:service:publish";
+    readonly RENDER_INVOKE: "dmb:render:invoke";
+    readonly RENDER_PUBLISH: "dmb:render:publish";
+    readonly TO_SERVICE: "dmb:to-service";
+    readonly TO_RENDER: "dmb:to-render";
+    readonly SIMULATOR_API: "dmb:simulator-api";
+    /** simulator → main: ack of an API_CALL request (carries success/fail args). */
+    readonly API_RESPONSE: "dmb:api:response";
+    /**
+     * simulator webview preload → main (sendSync): "is native-host mode on?".
+     * The guest preload can't read the launch `process.env`, so it asks main
+     * (which can) at install time. Reply is `e.returnValue = boolean`.
+     */
+    readonly NATIVE_HOST_ENABLED: "dmb:native-host-enabled";
+    /**
+     * simulator (DeviceShell) → main: the visible top-of-stack page bridgeId.
+     * Main has no z-order concept — the active page lives only in DeviceShell's
+     * ShellState — so devtools panels / automation that must target "the current
+     * page's render webContents" resolve it through this signal. Fire-and-forget.
+     */
+    readonly ACTIVE_PAGE: "dmb:active-page";
+    /**
+     * simulator (DeviceShell) → main: the FULL ordered page stack (bottom→top)
+     * whenever it changes. Main has no stack of its own (it only learns the
+     * active bridgeId via ACTIVE_PAGE), so automation's `App.getPageStack` needs
+     * this to report multi-page stacks. Fire-and-forget.
+     */
+    readonly PAGE_STACK: "dmb:page-stack";
+};
+export declare const SIMULATOR_EVENTS: {
+    readonly DOM_READY: "simulator:dom-ready";
+    readonly NAV_BAR: "simulator:navigation-bar";
+    readonly NAV_ACTION: "simulator:nav-action";
+    readonly TAB_ACTION: "simulator:tab-action";
+    /** main → simulator: invoke a wx.* API on the simulator-resident MiniApp. */
+    readonly API_CALL: "simulator:api-call";
+    /**
+     * main → simulator: the renderer toolbar picked a different device. Carries a
+     * NativeDeviceInfo; DeviceShell resizes the bezel + re-renders status bar /
+     * notch. The race-free INITIAL device rides NativeHostConfig.device (read
+     * synchronously at preload bridge-install); this event covers live changes.
+     */
+    readonly DEVICE_CHANGE: "simulator:device-change";
+};
+export declare const CHANNELS: {
+    readonly SPAWN: "dmb:spawn";
+    readonly DISPOSE: "dmb:dispose";
+    readonly PAGE_OPEN: "dmb:page:open";
+    readonly PAGE_CLOSE: "dmb:page:close";
+    readonly PAGE_LIFECYCLE: "dmb:page:lifecycle";
+    readonly NAV_CALLBACK: "dmb:nav:callback";
+    readonly SERVICE_INVOKE: "dmb:service:invoke";
+    readonly SERVICE_PUBLISH: "dmb:service:publish";
+    readonly RENDER_INVOKE: "dmb:render:invoke";
+    readonly RENDER_PUBLISH: "dmb:render:publish";
+    readonly TO_SERVICE: "dmb:to-service";
+    readonly TO_RENDER: "dmb:to-render";
+    readonly SIMULATOR_API: "dmb:simulator-api";
+    /** simulator → main: ack of an API_CALL request (carries success/fail args). */
+    readonly API_RESPONSE: "dmb:api:response";
+    /**
+     * simulator webview preload → main (sendSync): "is native-host mode on?".
+     * The guest preload can't read the launch `process.env`, so it asks main
+     * (which can) at install time. Reply is `e.returnValue = boolean`.
+     */
+    readonly NATIVE_HOST_ENABLED: "dmb:native-host-enabled";
+    /**
+     * simulator (DeviceShell) → main: the visible top-of-stack page bridgeId.
+     * Main has no z-order concept — the active page lives only in DeviceShell's
+     * ShellState — so devtools panels / automation that must target "the current
+     * page's render webContents" resolve it through this signal. Fire-and-forget.
+     */
+    readonly ACTIVE_PAGE: "dmb:active-page";
+    /**
+     * simulator (DeviceShell) → main: the FULL ordered page stack (bottom→top)
+     * whenever it changes. Main has no stack of its own (it only learns the
+     * active bridgeId via ACTIVE_PAGE), so automation's `App.getPageStack` needs
+     * this to report multi-page stacks. Fire-and-forget.
+     */
+    readonly PAGE_STACK: "dmb:page-stack";
+};
+/**
+ * Reply to a `NATIVE_HOST_ENABLED` sendSync. Main supplies the render-host
+ * file:// URLs (computed with node:path/url, which the simulator webview's
+ * preload lacks) so the preload can build the native-host bridge.
+ */
+export interface NativeHostConfig {
+    enabled: boolean;
+    renderHostHtmlUrl: string;
+    renderPreloadUrl: string;
+    /**
+     * The currently-selected device, if the renderer already pushed it before the
+     * simulator WCV's preload installed (it does — SetDeviceInfo precedes
+     * AttachNative). DeviceShell reads this as its initial device so it never
+     * mounts with the wrong bezel size while waiting for the first DEVICE_CHANGE.
+     * Absent only on the pre-spawn default path.
+     */
+    device?: NativeDeviceInfo;
+}
+export type BridgeChannel = typeof BRIDGE_CHANNELS[keyof typeof BRIDGE_CHANNELS];
+export type BridgeTarget = 'service' | 'render' | 'container';
+export type BridgeMessageType = 'loadResource' | 'serviceResourceLoaded' | 'renderResourceLoaded' | 'resourceLoaded' | 'firstRender' | 'appShow' | 'appHide' | 'stackShow' | 'stackHide' | 'pageShow' | 'pageHide' | 'pageReady' | 'pageUnload' | 'pageScroll' | 'pageResize' | 'pageRouteDone' | 'mC' | 'mR' | 'mU' | 't' | 'u' | 'ub' | 'triggerCallback' | 'invokeAPI' | 'h5SdkAction' | 'componentError' | 'domReady' | 'print' | 'renderHostReady' | 'serviceHostError' | string;
+export interface MessageEnvelope<TBody extends Record<string, unknown> = Record<string, unknown>> {
+    type: BridgeMessageType;
+    target: BridgeTarget;
+    body: TBody;
+}
+export interface HostEnvSnapshot {
+    brand: string;
+    model: string;
+    platform: string;
+    system: string;
+    version: string;
+    SDKVersion: string;
+    pixelRatio: number;
+    screenWidth: number;
+    screenHeight: number;
+    windowWidth: number;
+    windowHeight: number;
+    statusBarHeight: number;
+    language: string;
+    theme: string;
+    [key: string]: unknown;
+}
+/**
+ * Map the renderer's logical device metrics onto the subset of a
+ * HostEnvSnapshot the service-host window's `getSystemInfoSync` consumes.
+ * `windowHeight` excludes the status bar (the page area); `windowWidth` has no
+ * horizontal chrome. Zoom is intentionally absent — it is a display scale, not
+ * a logical-size change.
+ *
+ * Single source of truth for the device→host-env mapping, shared by the live
+ * `SetDeviceInfo` IPC path (main/ipc/simulator.ts) and the per-spawn host-env
+ * seeding (main/ipc/bridge-router.ts). Keeping them identical guarantees a
+ * service-host RESPAWN after a device change reports the same dims the live
+ * update pushed — otherwise a respawn would silently revert to the boot device.
+ */
+export declare function deviceInfoToHostEnv(d: NativeDeviceInfo): Partial<HostEnvSnapshot>;
+/**
+ * Subset of WeChat page `window` config plus tabBar list, parsed from
+ * `app-config.json` (`{app:{window,tabBar,pages,entryPagePath}, modules:{[pagePath]:{window}}}`).
+ * Mirrors mergePageConfig in dimina-fe: page-level keys override app-level.
+ */
+export interface PageWindowConfig {
+    navigationBarTitleText?: string;
+    navigationBarBackgroundColor?: string;
+    navigationBarTextStyle?: 'black' | 'white';
+    navigationStyle?: 'default' | 'custom';
+    homeButton?: boolean;
+    backgroundColor?: string;
+    backgroundTextStyle?: 'dark' | 'light';
+    enablePullDownRefresh?: boolean;
+    disableScroll?: boolean;
+    [key: string]: unknown;
+}
+export interface TabBarItem {
+    pagePath: string;
+    text?: string;
+    iconPath?: string;
+    selectedIconPath?: string;
+}
+export interface TabBarConfig {
+    color?: string;
+    selectedColor?: string;
+    backgroundColor?: string;
+    borderStyle?: 'black' | 'white';
+    position?: 'bottom' | 'top';
+    custom?: boolean;
+    list: TabBarItem[];
+}
+export interface AppManifest {
+    entryPagePath: string;
+    pages: string[];
+    tabBar?: TabBarConfig;
+}
+export interface SpawnRequest {
+    simulatorWcId?: number;
+    appId: string;
+    bridgeId?: string;
+    pagePath?: string;
+    scene?: number;
+    query?: Record<string, unknown>;
+    apiNamespaces?: string[];
+    hostEnvSnapshot?: Partial<HostEnvSnapshot>;
+    pkgRoot?: string;
+    root?: string;
+    /**
+     * Base URL of the dev server that serves the compiled mini-app, i.e. the
+     * SAME origin the simulator page was loaded from (`http://localhost:<port>/`).
+     * The dev server statically serves `<appId>/<root>/…` (app-config.json,
+     * logic.js, page bundles, styles) — exactly what the default dimina-fe
+     * `<webview>` fetches. The native-host render + service hosts source every
+     * resource from here, so we don't need a second resource server or a local
+     * compiled-output path. Trailing slash expected.
+     */
+    resourceBaseUrl?: string;
+}
+export interface SpawnResult {
+    appSessionId: string;
+    bridgeId: string;
+    pagePath: string;
+    serviceWcId: number;
+    resourceBaseUrl: string;
+    manifest: AppManifest;
+    rootWindowConfig: PageWindowConfig;
+}
+export interface PageOpenRequest {
+    appSessionId: string;
+    pagePath: string;
+    query?: Record<string, unknown>;
+    bridgeId?: string;
+}
+export interface PageOpenResult {
+    bridgeId: string;
+    pagePath: string;
+    windowConfig: PageWindowConfig;
+    isTab: boolean;
+}
+export interface PageClosePayload {
+    bridgeId: string;
+}
+export interface DisposePayload {
+    /** AppSession root bridgeId (legacy) or any page bridgeId. */
+    bridgeId: string;
+}
+export type PageLifecycleEvent = 'pageShow' | 'pageHide' | 'pageUnload' | 'stackShow' | 'stackHide' | 'appShow' | 'appHide';
+export interface PageLifecyclePayload {
+    appSessionId: string;
+    bridgeId: string;
+    event: PageLifecycleEvent;
+}
+/**
+ * Sent by simulator after a routing action (navigateTo etc.) completes so the
+ * main process can call sendCallback() against the original service-issued
+ * success/fail/complete ids.
+ */
+export interface NavCallbackPayload {
+    appSessionId: string;
+    ok: boolean;
+    errMsg: string;
+    callbacks: {
+        success?: unknown;
+        fail?: unknown;
+        complete?: unknown;
+    };
+}
+export interface ServiceInvokePayload {
+    bridgeId: string;
+    msg: MessageEnvelope;
+}
+export interface ServicePublishPayload {
+    bridgeId: string;
+    targetBridgeId?: string;
+    msg: MessageEnvelope;
+}
+/**
+ * `dmb:active-page` — simulator (DeviceShell) → main. Records which page is the
+ * visible top-of-stack so main-side services (WXML/element-inspect, automation)
+ * can resolve "the active page's render webContents" by bridgeId.
+ */
+export interface ActivePagePayload {
+    appSessionId: string;
+    bridgeId: string;
+}
+/**
+ * `dmb:page-stack` — simulator (DeviceShell) → main. The full ordered page
+ * stack (bottom→top) so `App.getPageStack` can report multi-page stacks.
+ */
+export interface PageStackEntry {
+    pagePath: string;
+    query: Record<string, unknown>;
+}
+export interface PageStackPayload {
+    appSessionId: string;
+    stack: PageStackEntry[];
+}
+export interface RenderInvokePayload {
+    bridgeId: string;
+    msg: MessageEnvelope;
+}
+export interface RenderPublishPayload {
+    bridgeId: string;
+    msg: MessageEnvelope;
+}
+export interface ToServicePayload {
+    msg: MessageEnvelope;
+}
+export interface ToRenderPayload {
+    msg: MessageEnvelope;
+}
+export interface SimulatorApiInvokePayload {
+    bridgeId: string;
+    name: string;
+    params: unknown;
+}
+/**
+ * `simulator:nav-action` — main → simulator window, carries router/tabBar
+ * intentions. Simulator owns the visual stack state and decides whether to
+ * push/pop webviews; it then calls back PAGE_LIFECYCLE + NAV_CALLBACK.
+ */
+export interface NavActionPayload {
+    appSessionId: string;
+    bridgeId: string;
+    name: 'navigateTo' | 'navigateBack' | 'redirectTo' | 'reLaunch' | 'switchTab';
+    params: Record<string, unknown>;
+    callbacks: {
+        success?: unknown;
+        fail?: unknown;
+        complete?: unknown;
+    };
+}
+/**
+ * `simulator:api-call` — main → simulator. Fallback path used when an
+ * invokeAPI name is not registered in the main-process `ctx.simulatorApis`
+ * registry: the simulator-resident MiniApp owns the wx.* handler (it can
+ * read DOM, open file pickers, etc.), so we forward the call there and wait
+ * for an `API_RESPONSE` ack.
+ */
+export interface ApiCallPayload {
+    appSessionId: string;
+    bridgeId: string;
+    requestId: string;
+    name: string;
+    params: Record<string, unknown>;
+    callbacks: {
+        success?: unknown;
+        fail?: unknown;
+        complete?: unknown;
+    };
+}
+/**
+ * `dmb:api:response` — simulator → main. Ack for an `API_CALL`. Main looks
+ * up `requestId` in its pending map and fires the original service-side
+ * success/fail/complete callbacks accordingly.
+ */
+export interface ApiResponsePayload {
+    appSessionId: string;
+    requestId: string;
+    ok: boolean;
+    /** Argument the simulator-side success/fail callback was invoked with. */
+    result?: unknown;
+    errMsg?: string;
+    /**
+     * Persistent-subscription marker (`keep: true` APIs, e.g.
+     * `audioListen`). When set, this response is one of potentially many
+     * fires of the same subscription: main re-fires the service-side success
+     * callback but keeps the pendingApiCall alive (does not delete it or fire
+     * `complete`) so subsequent fires of the same `requestId` are delivered.
+     * Cleanup happens on page/app teardown instead.
+     */
+    keep?: boolean;
+}
+/**
+ * `simulator:tab-action` — main → simulator window, carries dynamic TabBar
+ * API calls. Simulator updates TabBar React state and acknowledges via
+ * NAV_CALLBACK so the service-side wx.* callback fires.
+ */
+export interface TabActionPayload {
+    appSessionId: string;
+    bridgeId: string;
+    name: 'setTabBarStyle' | 'setTabBarItem' | 'showTabBar' | 'hideTabBar' | 'setTabBarBadge' | 'removeTabBarBadge' | 'showTabBarRedDot' | 'hideTabBarRedDot';
+    params: Record<string, unknown>;
+    callbacks: {
+        success?: unknown;
+        fail?: unknown;
+        complete?: unknown;
+    };
+}
+//# sourceMappingURL=bridge-channels.d.ts.map

package/dist/shared/bridge-channels.js

@@ -0,0 +1,81 @@
+export const BRIDGE_CHANNELS = {
+    SPAWN: 'dmb:spawn',
+    DISPOSE: 'dmb:dispose',
+    PAGE_OPEN: 'dmb:page:open',
+    PAGE_CLOSE: 'dmb:page:close',
+    PAGE_LIFECYCLE: 'dmb:page:lifecycle',
+    NAV_CALLBACK: 'dmb:nav:callback',
+    SERVICE_INVOKE: 'dmb:service:invoke',
+    SERVICE_PUBLISH: 'dmb:service:publish',
+    RENDER_INVOKE: 'dmb:render:invoke',
+    RENDER_PUBLISH: 'dmb:render:publish',
+    TO_SERVICE: 'dmb:to-service',
+    TO_RENDER: 'dmb:to-render',
+    SIMULATOR_API: 'dmb:simulator-api',
+    /** simulator → main: ack of an API_CALL request (carries success/fail args). */
+    API_RESPONSE: 'dmb:api:response',
+    /**
+     * simulator webview preload → main (sendSync): "is native-host mode on?".
+     * The guest preload can't read the launch `process.env`, so it asks main
+     * (which can) at install time. Reply is `e.returnValue = boolean`.
+     */
+    NATIVE_HOST_ENABLED: 'dmb:native-host-enabled',
+    /**
+     * simulator (DeviceShell) → main: the visible top-of-stack page bridgeId.
+     * Main has no z-order concept — the active page lives only in DeviceShell's
+     * ShellState — so devtools panels / automation that must target "the current
+     * page's render webContents" resolve it through this signal. Fire-and-forget.
+     */
+    ACTIVE_PAGE: 'dmb:active-page',
+    /**
+     * simulator (DeviceShell) → main: the FULL ordered page stack (bottom→top)
+     * whenever it changes. Main has no stack of its own (it only learns the
+     * active bridgeId via ACTIVE_PAGE), so automation's `App.getPageStack` needs
+     * this to report multi-page stacks. Fire-and-forget.
+     */
+    PAGE_STACK: 'dmb:page-stack',
+};
+export const SIMULATOR_EVENTS = {
+    DOM_READY: 'simulator:dom-ready',
+    NAV_BAR: 'simulator:navigation-bar',
+    NAV_ACTION: 'simulator:nav-action',
+    TAB_ACTION: 'simulator:tab-action',
+    /** main → simulator: invoke a wx.* API on the simulator-resident MiniApp. */
+    API_CALL: 'simulator:api-call',
+    /**
+     * main → simulator: the renderer toolbar picked a different device. Carries a
+     * NativeDeviceInfo; DeviceShell resizes the bezel + re-renders status bar /
+     * notch. The race-free INITIAL device rides NativeHostConfig.device (read
+     * synchronously at preload bridge-install); this event covers live changes.
+     */
+    DEVICE_CHANGE: 'simulator:device-change',
+};
+export const CHANNELS = BRIDGE_CHANNELS;
+/**
+ * Map the renderer's logical device metrics onto the subset of a
+ * HostEnvSnapshot the service-host window's `getSystemInfoSync` consumes.
+ * `windowHeight` excludes the status bar (the page area); `windowWidth` has no
+ * horizontal chrome. Zoom is intentionally absent — it is a display scale, not
+ * a logical-size change.
+ *
+ * Single source of truth for the device→host-env mapping, shared by the live
+ * `SetDeviceInfo` IPC path (main/ipc/simulator.ts) and the per-spawn host-env
+ * seeding (main/ipc/bridge-router.ts). Keeping them identical guarantees a
+ * service-host RESPAWN after a device change reports the same dims the live
+ * update pushed — otherwise a respawn would silently revert to the boot device.
+ */
+export function deviceInfoToHostEnv(d) {
+    return {
+        brand: d.brand,
+        model: d.model,
+        system: d.system,
+        platform: d.platform,
+        pixelRatio: d.pixelRatio,
+        screenWidth: d.screenWidth,
+        screenHeight: d.screenHeight,
+        windowWidth: d.screenWidth,
+        windowHeight: Math.max(0, d.screenHeight - d.statusBarHeight),
+        statusBarHeight: d.statusBarHeight,
+    };
+}
+//# sourceMappingURL=bridge-channels.js.map