@dimina-kit/devtools 0.4.0-dev.20260702175315 → 0.4.0-dev.20260703051110

package/dist/main/services/automation/handlers/app.js

@@ -76,122 +76,141 @@ appHandlers['App.getPageStack'] = async (ctx) => {
     }
     return { pageStack };
 };
-appHandlers['App.callWxMethod'] = async (ctx, params) => {
-    const method = params.method;
-    const args = params.args || [];
-    // NATIVE-HOST: the authoritative `wx.*` runs in the hidden service-host
-    // window (the simulator / render-guest context has no `wx`). Run EVERY method
-    // there — nav so the page stack goes through the real runtime path, and
-    // non-nav (setNavigationBarTitle / getSystemInfoSync / tabBar APIs / …) so
-    // they don't fall through to the default-arch eval-in-simulator path below,
-    // which throws "wx is not defined" under native-host.
-    if (ctx.bridge?.isNativeHost()) {
-        const serviceWc = ctx.bridge.getServiceWc();
-        if (!serviceWc)
-            throw new Error('Service host not connected');
-        if (NAV_METHODS.has(method) || method === 'navigateBack') {
-            const arg = method === 'navigateBack'
-                ? (args[0] ?? { delta: 1 })
-                : (args[0] ?? {});
-            // Capture the active page BEFORE navigating so we can wait for it to
-            // actually change, instead of blindly sleeping a fixed duration.
-            const since = ctx.bridge.getActiveBridgeId();
-            await serviceWc.executeJavaScript(`wx.${method}(${JSON.stringify(arg)})`);
-            // Wait for the bridge's `activePage` signal (the new page mounted), with a
-            // timeout floor = the old blind-wait duration. Resolves as soon as the new
-            // page is active — far faster than the fixed sleep for the common case —
-            // and still bounded for edges (e.g. switchTab back to an already-mounted
-            // tab keeps the same bridgeId, so it falls through to the floor, same as
-            // the old behaviour). See wait-active-page.ts.
-            const timeoutMs = method === 'navigateBack' ? 1500 : 2000;
-            await waitForActivePage(ctx.bridge, {
-                since,
-                timeoutMs,
-                onTimeout: () => console.warn(`[automation] ${method}: activePage signal not seen within ${timeoutMs}ms — proceeding on timeout floor`),
-            });
-            return { result: undefined };
+/** Nav (incl. navigateBack) on the native-host service-host `wx`, waiting for the page to actually change. */
+async function runNativeHostNav(bridge, serviceWc, method, args) {
+    const arg = method === 'navigateBack'
+        ? (args[0] ?? { delta: 1 })
+        : (args[0] ?? {});
+    // Capture the active page BEFORE navigating so we can wait for it to
+    // actually change, instead of blindly sleeping a fixed duration.
+    const since = bridge.getActiveBridgeId();
+    await serviceWc.executeJavaScript(`wx.${method}(${JSON.stringify(arg)})`);
+    // Wait for the bridge's `activePage` signal (the new page mounted), with a
+    // timeout floor = the old blind-wait duration. Resolves as soon as the new
+    // page is active — far faster than the fixed sleep for the common case —
+    // and still bounded for edges (e.g. switchTab back to an already-mounted
+    // tab keeps the same bridgeId, so it falls through to the floor, same as
+    // the old behaviour). See wait-active-page.ts.
+    const timeoutMs = method === 'navigateBack' ? 1500 : 2000;
+    await waitForActivePage(bridge, {
+        since,
+        timeoutMs,
+        onTimeout: () => console.warn(`[automation] ${method}: activePage signal not seen within ${timeoutMs}ms — proceeding on timeout floor`),
+    });
+    return { result: undefined };
+}
+/**
+ * Non-nav `wx.*` on the native-host service-host, returning its (sync) value.
+ * Async methods that report via a success callback return undefined here,
+ * same as the default-arch generic path (`runSimulatorGeneric`).
+ */
+async function runNativeHostGeneric(serviceWc, method, args) {
+    const argsStr = args.map((a) => JSON.stringify(a)).join(', ');
+    const result = await serviceWc.executeJavaScript(`
+    new Promise((resolve, reject) => {
+      try {
+        if (typeof wx === 'undefined' || typeof wx[${JSON.stringify(method)}] !== 'function') {
+          reject(new Error('wx.' + ${JSON.stringify(method)} + ' is not a function in service host'))
+          return
         }
-        // Non-nav: invoke on the service-host wx and return its (sync) value. Async
-        // methods that report via a success callback return undefined here, same as
-        // the default-arch generic path below.
-        const argsStr = args.map((a) => JSON.stringify(a)).join(', ');
-        const result = await serviceWc.executeJavaScript(`
-      new Promise((resolve, reject) => {
+        resolve(wx.${method}(${argsStr}))
+      } catch (e) { reject(e && e.message ? e.message : String(e)) }
+    })
+  `);
+    return { result };
+}
+/**
+ * NATIVE-HOST: the authoritative `wx.*` runs in the hidden service-host
+ * window (the simulator / render-guest context has no `wx`). Run EVERY method
+ * there — nav so the page stack goes through the real runtime path, and
+ * non-nav (setNavigationBarTitle / getSystemInfoSync / tabBar APIs / …) so
+ * they don't fall through to the default-arch eval-in-simulator path, which
+ * throws "wx is not defined" under native-host.
+ */
+async function runNativeHostWxMethod(bridge, method, args) {
+    const serviceWc = bridge.getServiceWc();
+    if (!serviceWc)
+        throw new Error('Service host not connected');
+    if (NAV_METHODS.has(method) || method === 'navigateBack') {
+        return runNativeHostNav(bridge, serviceWc, method, args);
+    }
+    return runNativeHostGeneric(serviceWc, method, args);
+}
+/**
+ * Try clicking a matching DOM element for a nav target. We can't use
+ * `inIframe` here — tabBar mini-apps keep prior tabs' iframes around
+ * (display:none) and `iframes[length-1]` ends up being the hidden,
+ * freshly-cached tab rather than the visible one. Pick the visible iframe
+ * explicitly.
+ */
+async function clickNavTarget(ctx, cleanUrl) {
+    return evalInSim(ctx, `(() => {
+    const iframes = Array.from(document.querySelectorAll('iframe'))
+    const visible = iframes.filter((f) => {
+      const cs = window.getComputedStyle(f)
+      if (cs.display === 'none' || cs.visibility === 'hidden') return false
+      const rect = f.getBoundingClientRect()
+      return rect.width > 0 && rect.height > 0
+    })
+    const target = visible[visible.length - 1] || iframes[iframes.length - 1]
+    if (!target || !target.contentDocument) return false
+    const path = ${JSON.stringify(cleanUrl)}
+    const el = Array.from(target.contentDocument.querySelectorAll('[data-path]'))
+      .find((e) => e.getAttribute('data-path') === path)
+    if (el) { el.click(); return true }
+    return false
+  })()`).catch(() => false);
+}
+/**
+ * Fallback cascade for navigation methods when no matching DOM element was
+ * found to click:
+ *   1. iframe wx[method] — page-iframe surface (older arch, where jdimina
+ *      installed `window.wx` on each page frame).
+ *   2. top-window wx[method] — set up by simulator/main.tsx, binds
+ *      MiniApp.switchTab / navigateTo / etc. Required for switchTab since
+ *      page-iframe wx (jdimina) doesn't expose it.
+ */
+async function invokeNavViaWx(ctx, method, cleanUrl) {
+    const apiName = JSON.stringify(method);
+    const urlJson = JSON.stringify(cleanUrl);
+    await evalInSim(ctx, `(() => {
+      const iframes = Array.from(document.querySelectorAll('iframe'))
+      for (const f of iframes) {
         try {
-          if (typeof wx === 'undefined' || typeof wx[${JSON.stringify(method)}] !== 'function') {
-            reject(new Error('wx.' + ${JSON.stringify(method)} + ' is not a function in service host'))
+          if (f.contentWindow && f.contentWindow.wx && typeof f.contentWindow.wx[${apiName}] === 'function') {
+            f.contentWindow.wx[${apiName}]({ url: ${urlJson} })
             return
           }
-          resolve(wx.${method}(${argsStr}))
-        } catch (e) { reject(e && e.message ? e.message : String(e)) }
-      })
-    `);
-        return { result };
-    }
-    // For navigation methods, handle specially via DOM click / wx.* on the iframe
-    if (['navigateTo', 'redirectTo', 'reLaunch', 'switchTab'].includes(method)) {
-        const opts = args[0];
-        const url = opts?.url;
-        if (url) {
-            const cleanUrl = url.startsWith('/') ? url : `/${url}`;
-            // Try clicking a matching DOM element first. We can't use `inIframe`
-            // here — tabBar mini-apps keep prior tabs' iframes around (display:none)
-            // and `iframes[length-1]` ends up being the hidden, freshly-cached tab
-            // rather than the visible one. Pick the visible iframe explicitly.
-            const clicked = await evalInSim(ctx, `(() => {
-        const iframes = Array.from(document.querySelectorAll('iframe'))
-        const visible = iframes.filter((f) => {
-          const cs = window.getComputedStyle(f)
-          if (cs.display === 'none' || cs.visibility === 'hidden') return false
-          const rect = f.getBoundingClientRect()
-          return rect.width > 0 && rect.height > 0
-        })
-        const target = visible[visible.length - 1] || iframes[iframes.length - 1]
-        if (!target || !target.contentDocument) return false
-        const path = ${JSON.stringify(cleanUrl)}
-        const el = Array.from(target.contentDocument.querySelectorAll('[data-path]'))
-          .find((e) => e.getAttribute('data-path') === path)
-        if (el) { el.click(); return true }
-        return false
-      })()`).catch(() => false);
-            if (!clicked) {
-                // Fallback cascade for navigation methods:
-                //   1. iframe wx[method] — page-iframe surface (older arch, where
-                //      jdimina installed `window.wx` on each page frame).
-                //   2. top-window wx[method] — set up by simulator/main.tsx, binds
-                //      MiniApp.switchTab / navigateTo / etc. Required for switchTab
-                //      since page-iframe wx (jdimina) doesn't expose it.
-                const apiName = JSON.stringify(method);
-                const urlJson = JSON.stringify(cleanUrl);
-                await evalInSim(ctx, `(() => {
-            const iframes = Array.from(document.querySelectorAll('iframe'))
-            for (const f of iframes) {
-              try {
-                if (f.contentWindow && f.contentWindow.wx && typeof f.contentWindow.wx[${apiName}] === 'function') {
-                  f.contentWindow.wx[${apiName}]({ url: ${urlJson} })
-                  return
-                }
-              } catch (_) {}
-            }
-            if (typeof wx !== 'undefined' && wx && typeof wx[${apiName}] === 'function') {
-              wx[${apiName}]({ url: ${urlJson} })
-            }
-          })()`);
-            }
-            // Wait for navigation
-            await new Promise((r) => setTimeout(r, 2000));
-        }
-        return { result: undefined };
-    }
-    // For navigateBack
-    if (method === 'navigateBack') {
-        await evalInSim(ctx, 'history.back()');
-        await new Promise((r) => setTimeout(r, 1500));
+        } catch (_) {}
+      }
+      if (typeof wx !== 'undefined' && wx && typeof wx[${apiName}] === 'function') {
+        wx[${apiName}]({ url: ${urlJson} })
+      }
+    })()`);
+}
+/** Default-arch nav: handled via DOM click / wx.* on the iframe. */
+async function runSimulatorNav(ctx, method, args) {
+    const opts = args[0];
+    const url = opts?.url;
+    if (!url)
         return { result: undefined };
+    const cleanUrl = url.startsWith('/') ? url : `/${url}`;
+    const clicked = await clickNavTarget(ctx, cleanUrl);
+    if (!clicked) {
+        await invokeNavViaWx(ctx, method, cleanUrl);
     }
-    // General wx method call
+    // Wait for navigation
+    await new Promise((r) => setTimeout(r, 2000));
+    return { result: undefined };
+}
+async function runSimulatorNavigateBack(ctx) {
+    await evalInSim(ctx, 'history.back()');
+    await new Promise((r) => setTimeout(r, 1500));
+    return { result: undefined };
+}
+/** General wx method call — async wx methods with success/fail callbacks. */
+async function runSimulatorGeneric(ctx, method, args) {
     const argsStr = args.map((a) => JSON.stringify(a)).join(', ');
-    // Async wx methods with success/fail callbacks
     const result = await evalInSim(ctx, `
     new Promise((resolve, reject) => {
       try {
@@ -203,6 +222,21 @@ appHandlers['App.callWxMethod'] = async (ctx, params) => {
     })
   `);
     return { result };
+}
+appHandlers['App.callWxMethod'] = async (ctx, params) => {
+    const method = params.method;
+    const args = params.args || [];
+    const bridge = ctx.bridge;
+    if (bridge?.isNativeHost()) {
+        return runNativeHostWxMethod(bridge, method, args);
+    }
+    if (NAV_METHODS.has(method)) {
+        return runSimulatorNav(ctx, method, args);
+    }
+    if (method === 'navigateBack') {
+        return runSimulatorNavigateBack(ctx);
+    }
+    return runSimulatorGeneric(ctx, method, args);
 };
 appHandlers['App.callFunction'] = async (ctx, params) => {
     const fnDecl = params.functionDeclaration;

package/dist/main/services/mcp/tools/simulator-tools.js

@@ -11,6 +11,111 @@
  */
 import { z } from 'zod';
 import { getClient } from '../target-manager.js';
+function ok(text) {
+    return { content: [{ type: 'text', text }] };
+}
+function err(msg) {
+    return { content: [{ type: 'text', text: `Error: ${msg}` }], isError: true };
+}
+async function clickAt(c, x, y) {
+    await c.Input.dispatchMouseEvent({ type: 'mousePressed', x, y, button: 'left', clickCount: 1 });
+    await c.Input.dispatchMouseEvent({ type: 'mouseReleased', x, y, button: 'left', clickCount: 1 });
+}
+async function tapCoord(c, x, y) {
+    if (typeof x !== 'number' || typeof y !== 'number')
+        return err('tap_coord requires x and y');
+    await clickAt(c, x, y);
+    return ok(`Tapped at (${x}, ${y})`);
+}
+/**
+ * In-page expression evaluated by `tap_selector`: locates the nth match,
+ * scrolls it into view, and reports its center point (or a reason it can't be
+ * tapped) so the caller can dispatch a real mouse click at that point.
+ */
+function buildTapSelectorExpression(selector, index) {
+    return `(() => {
+    const payload = ${JSON.stringify({ selector, index })}
+    try {
+      const matches = Array.from(document.querySelectorAll(payload.selector))
+      if (matches.length === 0) {
+        return { ok: false, reason: 'no_match', message: \`selector matched no elements: \${payload.selector}\` }
+      }
+      if (payload.index < 0 || payload.index >= matches.length) {
+        return { ok: false, reason: 'out_of_range', message: \`nth \${payload.index} out of range (matches: \${matches.length})\` }
+      }
+      const element = matches[payload.index]
+      element.scrollIntoView({ block: 'center', inline: 'center' })
+      const rect = element.getBoundingClientRect()
+      if (rect.width === 0 || rect.height === 0) {
+        return { ok: false, reason: 'not_visible', message: \`selector matched an element, but it is not visible or rendered (zero rect): \${payload.selector}[\${payload.index}]\` }
+      }
+      return {
+        ok: true,
+        selector: payload.selector,
+        index: payload.index,
+        x: rect.left + rect.width / 2,
+        y: rect.top + rect.height / 2,
+        rect: { left: rect.left, top: rect.top, width: rect.width, height: rect.height },
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error)
+      return { ok: false, reason: 'selector_error', message: \`invalid selector: \${payload.selector} (\${message})\` }
+    }
+  })()`;
+}
+async function tapSelector(c, selector, nth) {
+    if (!selector)
+        return err('tap_selector requires selector');
+    const index = nth ?? 0;
+    const expression = buildTapSelectorExpression(selector, index);
+    const result = await c.Runtime.evaluate({ expression, returnByValue: true, awaitPromise: true });
+    const value = result.result?.value;
+    if (!value)
+        return err(`selector evaluation returned no result: ${selector}[${index}]`);
+    if (!value.ok)
+        return err(value.message);
+    await clickAt(c, value.x, value.y);
+    return ok(`Tapped selector ${value.selector}[${value.index}] at (${value.x}, ${value.y}) within rect (${value.rect.left}, ${value.rect.top}, ${value.rect.width} x ${value.rect.height})`);
+}
+async function typeText(c, selector, nth, text) {
+    if (!selector || typeof text !== 'string')
+        return err('type requires selector and text');
+    const { root } = await c.DOM.getDocument({ depth: 0 });
+    const { nodeIds } = await c.DOM.querySelectorAll({ nodeId: root.nodeId, selector });
+    if (!nodeIds || nodeIds.length === 0)
+        return err(`selector matched no elements: ${selector}`);
+    const index = nth ?? 0;
+    if (index < 0 || index >= nodeIds.length)
+        return err(`nth ${index} out of range (matches: ${nodeIds.length})`);
+    await c.DOM.focus({ nodeId: nodeIds[index] });
+    try {
+        await c.Input.insertText({ text });
+    }
+    catch {
+        for (const ch of text) {
+            await c.Input.dispatchKeyEvent({ type: 'char', text: ch });
+        }
+    }
+    return ok(`Typed ${text.length} char(s) into ${selector}[${index}]`);
+}
+async function scrollAt(c, x, y, deltaX, deltaY) {
+    if (typeof x !== 'number' || typeof y !== 'number' || typeof deltaX !== 'number' || typeof deltaY !== 'number') {
+        return err('scroll requires x, y, deltaX, deltaY');
+    }
+    await c.Input.dispatchMouseEvent({ type: 'mouseWheel', x, y, deltaX, deltaY });
+    return ok(`Scrolled at (${x}, ${y}) by (${deltaX}, ${deltaY})`);
+}
+async function dispatchKey(c, key) {
+    if (!key)
+        return err('key requires key');
+    const isSingleChar = key.length === 1;
+    const down = { type: 'keyDown', key, code: key };
+    if (isSingleChar)
+        down.text = key;
+    await c.Input.dispatchKeyEvent(down);
+    await c.Input.dispatchKeyEvent({ type: 'keyUp', key, code: key });
+    return ok(`Dispatched key ${key}`);
+}
 export function registerSimulatorTools(server) {
     server.tool('simulator_navigate', 'Navigate the simulator to a URL, or reload the current page', {
         url: z.string().optional().describe('URL to navigate to'),
@@ -40,104 +145,20 @@ export function registerSimulatorTools(server) {
         deltaY: z.number().optional().describe('Vertical wheel delta for `scroll`'),
     }, async ({ action, x, y, selector, nth, text, key, deltaX, deltaY }) => {
         const c = getClient('simulator');
-        const err = (msg) => ({ content: [{ type: 'text', text: `Error: ${msg}` }], isError: true });
-        const clickAt = async (cx, cy) => {
-            await c.Input.dispatchMouseEvent({ type: 'mousePressed', x: cx, y: cy, button: 'left', clickCount: 1 });
-            await c.Input.dispatchMouseEvent({ type: 'mouseReleased', x: cx, y: cy, button: 'left', clickCount: 1 });
-        };
-        if (action === 'tap_coord') {
-            if (typeof x !== 'number' || typeof y !== 'number')
-                return err('tap_coord requires x and y');
-            await clickAt(x, y);
-            return { content: [{ type: 'text', text: `Tapped at (${x}, ${y})` }] };
-        }
-        if (action === 'tap_selector') {
-            if (!selector)
-                return err('tap_selector requires selector');
-            const index = nth ?? 0;
-            const expression = `(() => {
-        const payload = ${JSON.stringify({ selector, index })}
-        try {
-          const matches = Array.from(document.querySelectorAll(payload.selector))
-          if (matches.length === 0) {
-            return { ok: false, reason: 'no_match', message: \`selector matched no elements: \${payload.selector}\` }
-          }
-          if (payload.index < 0 || payload.index >= matches.length) {
-            return { ok: false, reason: 'out_of_range', message: \`nth \${payload.index} out of range (matches: \${matches.length})\` }
-          }
-          const element = matches[payload.index]
-          element.scrollIntoView({ block: 'center', inline: 'center' })
-          const rect = element.getBoundingClientRect()
-          if (rect.width === 0 || rect.height === 0) {
-            return { ok: false, reason: 'not_visible', message: \`selector matched an element, but it is not visible or rendered (zero rect): \${payload.selector}[\${payload.index}]\` }
-          }
-          return {
-            ok: true,
-            selector: payload.selector,
-            index: payload.index,
-            x: rect.left + rect.width / 2,
-            y: rect.top + rect.height / 2,
-            rect: { left: rect.left, top: rect.top, width: rect.width, height: rect.height },
-          }
-        } catch (error) {
-          const message = error instanceof Error ? error.message : String(error)
-          return { ok: false, reason: 'selector_error', message: \`invalid selector: \${payload.selector} (\${message})\` }
-        }
-      })()`;
-            const result = await c.Runtime.evaluate({ expression, returnByValue: true, awaitPromise: true });
-            const value = result.result?.value;
-            if (!value)
-                return err(`selector evaluation returned no result: ${selector}[${index}]`);
-            if (!value.ok)
-                return err(value.message);
-            await clickAt(value.x, value.y);
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Tapped selector ${value.selector}[${value.index}] at (${value.x}, ${value.y}) within rect (${value.rect.left}, ${value.rect.top}, ${value.rect.width} x ${value.rect.height})`,
-                    }],
-            };
-        }
-        if (action === 'type') {
-            if (!selector || typeof text !== 'string')
-                return err('type requires selector and text');
-            const { root } = await c.DOM.getDocument({ depth: 0 });
-            const { nodeIds } = await c.DOM.querySelectorAll({ nodeId: root.nodeId, selector });
-            if (!nodeIds || nodeIds.length === 0)
-                return err(`selector matched no elements: ${selector}`);
-            const index = nth ?? 0;
-            if (index < 0 || index >= nodeIds.length)
-                return err(`nth ${index} out of range (matches: ${nodeIds.length})`);
-            await c.DOM.focus({ nodeId: nodeIds[index] });
-            try {
-                await c.Input.insertText({ text });
-            }
-            catch {
-                for (const ch of text) {
-                    await c.Input.dispatchKeyEvent({ type: 'char', text: ch });
-                }
-            }
-            return { content: [{ type: 'text', text: `Typed ${text.length} char(s) into ${selector}[${index}]` }] };
-        }
-        if (action === 'scroll') {
-            if (typeof x !== 'number' || typeof y !== 'number' || typeof deltaX !== 'number' || typeof deltaY !== 'number') {
-                return err('scroll requires x, y, deltaX, deltaY');
-            }
-            await c.Input.dispatchMouseEvent({ type: 'mouseWheel', x, y, deltaX, deltaY });
-            return { content: [{ type: 'text', text: `Scrolled at (${x}, ${y}) by (${deltaX}, ${deltaY})` }] };
-        }
-        if (action === 'key') {
-            if (!key)
-                return err('key requires key');
-            const isSingleChar = key.length === 1;
-            const down = { type: 'keyDown', key, code: key };
-            if (isSingleChar)
-                down.text = key;
-            await c.Input.dispatchKeyEvent(down);
-            await c.Input.dispatchKeyEvent({ type: 'keyUp', key, code: key });
-            return { content: [{ type: 'text', text: `Dispatched key ${key}` }] };
+        switch (action) {
+            case 'tap_coord':
+                return tapCoord(c, x, y);
+            case 'tap_selector':
+                return tapSelector(c, selector, nth);
+            case 'type':
+                return typeText(c, selector, nth, text);
+            case 'scroll':
+                return scrollAt(c, x, y, deltaX, deltaY);
+            case 'key':
+                return dispatchKey(c, key);
+            default:
+                return err(`unknown action: ${String(action)}`);
         }
-        return err(`unknown action: ${action}`);
     });
 }
 //# sourceMappingURL=simulator-tools.js.map

package/dist/main/services/network-forward/dispatch-batch.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Pure batch-packing for the native dispatch queue: greedily pack queued CDP
+ * messages up to `maxBatchChars` so one `executeJavaScript` call stays sized,
+ * pulling any oversized message (over `maxSingleChars`) into `chunked` for the
+ * separate chunked transport instead.
+ *
+ * An oversized message reached while `batch` is still empty is queued into
+ * `chunked` immediately and packing continues past it, so several oversized
+ * messages in a row are all pulled out in one pass. One reached once `batch`
+ * already has items stops packing there, leaving it (and everything after) in
+ * `remaining` for the next flush — this preserves delivery order across passes.
+ */
+export interface PackedDispatchBatch {
+    /** Messages to send in one `executeJavaScript` batch dispatch. */
+    batch: string[];
+    /** Oversized messages to dispatch individually via the chunked transport. */
+    chunked: string[];
+    /** Whatever the queue had left after this pass. */
+    remaining: string[];
+}
+export declare function packDispatchBatch(queue: readonly string[], maxSingleChars: number, maxBatchChars: number): PackedDispatchBatch;
+//# sourceMappingURL=dispatch-batch.d.ts.map

package/dist/main/services/network-forward/dispatch-batch.js

@@ -0,0 +1,21 @@
+export function packDispatchBatch(queue, maxSingleChars, maxBatchChars) {
+    const batch = [];
+    const chunked = [];
+    let batchChars = 0;
+    let i = 0;
+    for (; i < queue.length; i++) {
+        const msg = queue[i];
+        if (msg.length > maxSingleChars) {
+            if (batch.length > 0)
+                break;
+            chunked.push(msg);
+            continue;
+        }
+        if (batch.length > 0 && batchChars + msg.length > maxBatchChars)
+            break;
+        batch.push(msg);
+        batchChars += msg.length;
+    }
+    return { batch, chunked, remaining: queue.slice(i) };
+}
+//# sourceMappingURL=dispatch-batch.js.map

package/dist/main/services/network-forward/index.js

@@ -1,5 +1,6 @@
 import { DisposableRegistry, toDisposable } from '@dimina-kit/electron-deck/main';
 import { isFrontendSettled } from '../views/inject-when-ready.js';
+import { packDispatchBatch } from './dispatch-batch.js';
 // ── requestId namespacing (pure, testable) ──────────────────────────────────
 /**
  * CDP events whose `params.requestId` we rewrite into the virtual namespace.
@@ -375,26 +376,10 @@ export function createNetworkForwarder(bridge) {
         if (sink === 'idle')
             beginProbing();
         // Pack greedily up to MAX_BATCH_CHARS so one executeJavaScript stays sized;
-        // oversized single messages go via the chunked transport.
-        const batch = [];
-        let batchChars = 0;
-        let i = 0;
-        for (; i < dispatchQueue.length; i++) {
-            const msg = dispatchQueue[i];
-            if (msg.length > MAX_SINGLE_DISPATCH_CHARS) {
-                // Flush whatever's accumulated first to preserve ordering, then chunk.
-                if (batch.length > 0)
-                    break;
-                dispatchChunked(wc, msg);
-                continue;
-            }
-            if (batch.length > 0 && batchChars + msg.length > MAX_BATCH_CHARS)
-                break;
-            batch.push(msg);
-            batchChars += msg.length;
-        }
-        // Everything up to i was either batched or chunk-dispatched; keep the rest.
-        const remaining = dispatchQueue.slice(i);
+        // oversized single messages go via the chunked transport (see packDispatchBatch).
+        const { batch, chunked, remaining } = packDispatchBatch(dispatchQueue, MAX_SINGLE_DISPATCH_CHARS, MAX_BATCH_CHARS);
+        for (const msg of chunked)
+            dispatchChunked(wc, msg);
         if (batch.length === 0) {
             // Only chunked messages were processed this turn; continue with the rest.
             dispatchQueue = remaining;