u-foo 2.3.32 → 2.4.0

package/src/ui/{components → ink}/MultilineInput.js

@@ -3,10 +3,8 @@
 /**
  * Multiline text input for the ink-based ucode TUI.
  *
- * Mirrors the behaviour of the blessed `_listener` in src/code/tui.js, but
- * built on ink's useInput. Cursor math is delegated to src/ui/format so the
- * legacy and ink editors stay in sync (and so the existing jest coverage of
- * those helpers protects this component too).
+ * Built on ink's useInput. Cursor math is delegated to src/ui/format so
+ * jest can cover the editor behaviour without mounting ink.
  *
  * Props:
  *   value (string)              text contents (controlled)
@@ -39,9 +37,108 @@
 
 const fmt = require("../format");
 
+// IME cursor parking interacts with ink's frame rendering. Two facts about
+// ink make the naive "move cursor up in useEffect" approach insufficient:
+//
+//   1. ink throttles onRender to 32ms (ink.js:39), so frame writes happen
+//      AFTER our useEffect, not before — anything we wrote in useEffect ends
+//      up getting overwritten by ink's parking cursor at the bottom of the
+//      next frame, which is what the user sees as "光标被结尾抢走".
+//
+//   2. ink's log-update emits ansi-escapes.eraseLines(N) before each frame:
+//      a sequence of `eraseLine + cursorUp` pairs starting from "wherever
+//      the cursor currently is". If our IME hack left the cursor mid-frame,
+//      ink's relative cursorUp walks past the top of the frame and tramples
+//      lines above it.
+//
+// Fix: wrap stdout.write once. Before any frame-shaped write (starts with
+// ESC[2K from eraseLines, or ESC[2J from full-screen rerender), push the
+// cursor back DOWN to the parking row so ink's math is restored. AFTER the
+// frame write, if the IME park target is active, re-emit the cursor-up +
+// CHA so the hardware cursor follows the inverse caret again. This way the
+// caret stays parked at the IME-visible row even when ink's throttled write
+// fires long after React commit.
+const __imeStdoutState = new WeakSet();
+const __imeCursor = {
+  active: false,
+  // Where to park the cursor: rowsUp above ink's "row after last frame line"
+  // anchor, and 0-based terminal column.
+  parkRowsUp: 0,
+  parkCol: 0,
+  // How many rows up we last actually moved the cursor — used to undo the
+  // move before ink runs its relative eraseLines. ALWAYS matches the move
+  // we last wrote, regardless of whether that was through the patched
+  // stdout write or the useEffect path.
+  movedUpRows: 0,
+  // Tracks whether the LAST frame ink wrote ended with '\n' (the log-update
+  // path) or not (the full-screen path). The anchor row is one row higher
+  // when there's no trailing newline, which shifts subsequent restore-down
+  // math by one. Without this flag, useEffect after a full-screen frame
+  // restores down too far and overshoots upward → a "ghost caret" sits one
+  // or more rows above the real caret.
+  lastFrameHadNewline: true,
+};
+
+function isFrameWrite(chunk) {
+  if (typeof chunk !== "string" && !(chunk instanceof String)) return false;
+  const str = String(chunk);
+  // eraseLines(N>0) starts with ESC[2K; full-screen clear starts with ESC[2J.
+  return str.startsWith("\x1b[2K") || str.startsWith("\x1b[2J");
+}
+
+// Compute "rows up from the current anchor to the caret". The anchor sits
+// one row below the last frame line when the frame ended with '\n', and AT
+// the last frame line otherwise — so a frame with no trailing newline needs
+// one fewer row up to land on the caret.
+function rowsUpFromAnchor() {
+  const base = __imeCursor.parkRowsUp;
+  return __imeCursor.lastFrameHadNewline ? base : Math.max(0, base - 1);
+}
+
+function applyParkSequence(parkRowsUp) {
+  if (!__imeCursor.active) return "";
+  const up = parkRowsUp > 0 ? `\x1b[${parkRowsUp}A` : "";
+  const col = `\x1b[${__imeCursor.parkCol + 1}G`; // CHA is 1-based
+  __imeCursor.movedUpRows = parkRowsUp;
+  return `\x1b[?25h${up}${col}`;
+}
+
+function patchStdoutForIME(out) {
+  if (!out || typeof out.write !== "function" || __imeStdoutState.has(out)) {
+    return;
+  }
+  __imeStdoutState.add(out);
+  const originalWrite = out.write.bind(out);
+  out.write = function patchedWrite(chunk, encoding, callback) {
+    if (!isFrameWrite(chunk) || (typeof chunk !== "string" && !(chunk instanceof String))) {
+      return originalWrite(chunk, encoding, callback);
+    }
+    // Combine "hide cursor + restore-to-anchor + ink's frame + reposition +
+    // show cursor" into a SINGLE write so the terminal processes the whole
+    // transition atomically. With ink's eraseLines walking the cursor up
+    // through the frame mid-write, even one stray byte between escape
+    // sequences can leave the hardware cursor visible on an intermediate
+    // row for a frame — exactly the "faint cursor above the real one"
+    // ghost the user reports.
+    const str = String(chunk);
+    let prefix = "\x1b[?25l"; // hide cursor for the whole transition
+    if (__imeCursor.movedUpRows > 0) {
+      // Push the cursor back down to ink's "after last frame line" anchor
+      // so the relative cursorUp inside eraseLines walks the right rows.
+      prefix += `\x1b[${__imeCursor.movedUpRows}B`;
+      __imeCursor.movedUpRows = 0;
+    }
+    // Record which ink path this frame took so subsequent restores-down know
+    // where the anchor actually sits.
+    __imeCursor.lastFrameHadNewline = str.endsWith("\n");
+    const suffix = applyParkSequence(rowsUpFromAnchor()) || "\x1b[?25l";
+    return originalWrite(prefix + str + suffix, encoding, callback);
+  };
+}
+
 function createMultilineInput({ React, ink }) {
   const { useState, useCallback, useMemo, useEffect } = React;
-  const { Box, Text, useInput } = ink;
+  const { Box, Text, useInput, useStdout } = ink;
   const h = React.createElement;
 
   return function MultilineInput({
@@ -61,6 +158,12 @@ function createMultilineInput({ React, ink }) {
     promptPrefix = "› ",
     promptColor = "magenta",
     borderColor = "gray",
+    // How many terminal rows of UI sit *below* the bottom of this input box
+    // (status line, dashboard rows, etc.). The component uses this to compute
+    // how far up the hardware cursor needs to be moved after each render so
+    // the IME composition window pops up at the visible (inverse) cursor
+    // instead of at the bottom of the screen.
+    linesBelowInput = 0,
   }) {
     // Cursor is owned by this component. preferredCol tracks the visual
     // column we want to keep when bouncing across lines of different widths
@@ -300,6 +403,128 @@ function createMultilineInput({ React, ink }) {
       [value, wrapWidth, cursorPos]
     );
 
+    // Hardware-cursor parking for IME support. ink hides the terminal cursor
+    // by default and parks it after the last frame line; macOS/Linux IMEs
+    // (Pinyin, kkc, etc.) anchor the candidate window to the *hardware*
+    // cursor, so without this hack Chinese input pops up at the bottom-right
+    // instead of next to the inverse-block caret. We compute the row offset
+    // of the inverse caret from the bottom of ink's rendered frame and emit
+    // ANSI cursor-position escapes after every render.
+    //
+    //   ink frame layout (top→bottom)
+    //     ... chat log ...
+    //     ┌── input border top ──┐         <- visualRows[0]
+    //     │ › row 0              │
+    //     │   row 1              │
+    //     └── input border bot ──┘
+    //     status line                       <- linesBelowInput rows
+    //     dashboard row(s)
+    //     <ink parks cursor here>
+    const { stdout } = useStdout() || {};
+    // Find the visual (row, col) of the cursor inside the wrapped layout.
+    let cursorVisualRow = 0;
+    let cursorVisualCol = 0;
+    {
+      let placed = false;
+      for (let r = 0; r < visualRows.length && !placed; r += 1) {
+        const row = visualRows[r];
+        let col = 0;
+        for (const seg of row.segments) {
+          if (seg.cursor) {
+            cursorVisualRow = r;
+            cursorVisualCol = col;
+            placed = true;
+            break;
+          }
+          col += fmt.displayCellWidth(seg.text);
+        }
+      }
+      if (!placed) {
+        // Cursor at end-of-input on a fresh row.
+        cursorVisualRow = Math.max(0, visualRows.length - 1);
+        cursorVisualCol = 0;
+        const lastRow = visualRows[cursorVisualRow];
+        if (lastRow) {
+          for (const seg of lastRow.segments) {
+            if (seg.cursor) break;
+            cursorVisualCol += fmt.displayCellWidth(seg.text);
+          }
+        }
+      }
+    }
+    const promptCols = cursorVisualRow === 0
+      ? fmt.displayCellWidth(promptPrefix)
+      : 2; // "  " indent on continuation rows
+    const cursorTermCol = promptCols + cursorVisualCol; // 0-based column
+
+    // Distance from the cursor's row to the parking row that ink will leave
+    // behind: bottom border (1) + linesBelowInput + the trailing newline ink
+    // appends to its frame string (1, see ink/log-update.js).
+    const rowsBelowCursor = (visualRows.length - 1 - cursorVisualRow)
+      + 1 // bottom border row of the input box
+      + Math.max(0, Math.floor(Number(linesBelowInput) || 0))
+      + 1; // ink appends "\n" after the frame, so the cursor sits one extra
+           // line below the last printed row
+
+    useEffect(() => {
+      const out = stdout || process.stdout;
+      if (!out || typeof out.write !== "function" || !out.isTTY) {
+        __imeCursor.active = false;
+        return undefined;
+      }
+      if (!interactive) {
+        // Hand the cursor back to ink and stop chasing the caret.
+        if (__imeCursor.movedUpRows > 0) {
+          out.write(`\x1b[${__imeCursor.movedUpRows}B`);
+          __imeCursor.movedUpRows = 0;
+        }
+        __imeCursor.active = false;
+        return undefined;
+      }
+      patchStdoutForIME(out);
+      // Publish the desired park target so the stdout monkey-patch can
+      // re-park after every throttled ink frame write.
+      __imeCursor.active = true;
+      __imeCursor.parkRowsUp = rowsBelowCursor;
+      __imeCursor.parkCol = cursorTermCol;
+      // Park immediately — covers cases where ink has nothing to render
+      // (output unchanged) and won't fire a frame write at all, and keeps
+      // the caret visible between frames. Combine hide + restore + park +
+      // show into a single write so the terminal never sees the cursor at
+      // an intermediate row.
+      //
+      // CRITICAL: the move-up amount must match the anchor that movedUpRows
+      // was measured against. If the last frame ended without '\n' (the
+      // full-screen path), the anchor is one row higher than the log-update
+      // case, so we use rowsUpFromAnchor() rather than parkRowsUp directly.
+      // Otherwise restoring down by movedUpRows then moving up parkRowsUp
+      // overshoots by one and leaves the hardware cursor one row above the
+      // inverse caret — the residual "ghost cursor" symptom.
+      let combined = "\x1b[?25l";
+      if (__imeCursor.movedUpRows > 0) {
+        combined += `\x1b[${__imeCursor.movedUpRows}B`;
+        __imeCursor.movedUpRows = 0;
+      }
+      combined += applyParkSequence(rowsUpFromAnchor());
+      out.write(combined);
+      return undefined;
+    });
+
+    // On unmount, return the cursor to ink's expected parking row (so the
+    // next frame ink renders after us doesn't trample lines above its frame)
+    // and re-hide it so the rest of ink's lifetime behaves as before.
+    useEffect(() => () => {
+      const out = stdout || process.stdout;
+      __imeCursor.active = false;
+      if (out && typeof out.write === "function" && out.isTTY) {
+        const restore = __imeCursor.movedUpRows > 0
+          ? `\x1b[${__imeCursor.movedUpRows}B`
+          : "";
+        __imeCursor.movedUpRows = 0;
+        out.write(`${restore}\x1b[?25l`);
+      }
+    }, [stdout]);
+
     return h(Box, {
       borderStyle: "single",
       borderTop: true,

package/src/ui/{components → ink}/UcodeApp.js

@@ -1,11 +1,9 @@
 "use strict";
 
 /**
- * Ink-based ucode TUI. Behaviourally equivalent to runUcodeBlessedTui in
- * src/code/tui.js but rendered via React + ink.
+ * Ink-based ucode TUI rendered via React + ink.
  *
- * Activation: Ink is the default ucode TUI. Set UFOO_TUI=blessed to use
- * the legacy blessed renderer while it remains available as a fallback.
+ * Activation: this is the only ucode TUI.
  *
  * Coverage today: banner, scrolling log via <Static>, tool-call merge with
  * Ctrl+O expand, multiline editor (see MultilineInput.js), spinner+phase
@@ -22,7 +20,7 @@ const { createMultilineInput } = require("./MultilineInput");
 
 function createUcodeApp({ React, ink, props, interactive = true }) {
   const { useEffect, useState, useCallback, useRef } = React;
-  const { Box, Text, Static, useInput, useApp, useStdout } = ink;
+  const { Box, Text, useInput, useApp, useStdout } = ink;
   const h = React.createElement;
   const MultilineInput = createMultilineInput({ React, ink });
 
@@ -38,6 +36,7 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
       banner.concat([""]).map((line, idx) => ({ id: `b-${idx}`, text: line }))
     );
     const [draft, setDraft] = useState("");
+    const [draftVersion, setDraftVersion] = useState(0);
     // status: idle when message === "". `type` picks a STATUS_INDICATORS
     // bucket; `showTimer` and `startedAt` reproduce the blessed spinner
     // controls. The BG suffix is computed from backgroundTasksRef and
@@ -181,6 +180,7 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
         if (transition.moved) {
           setHistoryIndex(transition.nextHistoryIndex);
           setDraft(transition.nextValue);
+          setDraftVersion((v) => v + 1);
           return;
         }
       }
@@ -204,6 +204,7 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
         if (nextIndex !== historyIndex || draft !== inputHistory[nextIndex]) {
           setHistoryIndex(nextIndex);
           setDraft(inputHistory[nextIndex] || "");
+          setDraftVersion((v) => v + 1);
           return;
         }
       }
@@ -628,6 +629,7 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
       const trimmed = value.trim();
       if (!trimmed) return;
       setDraft("");
+      setDraftVersion((v) => v + 1);
       setInputHistory((prev) => {
         const next = prev.concat([trimmed]).slice(-200);
         setHistoryIndex(next.length);
@@ -668,8 +670,10 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
     }, { isActive: interactive });
 
     return h(Box, { flexDirection: "column", width: "100%" },
-      h(Static, { items: logLines }, (item) =>
-        h(Text, { key: item.id }, item.text || " ")
+      h(Box, { flexDirection: "column", width: "100%" },
+        ...logLines.map((item) =>
+          h(Text, { key: item.id }, item.text || " ")
+        )
       ),
       activeMerge ? h(Box, null,
         h(Text, { color: activeMerge.entries.some((e) => e.isError) ? "red" : "cyan" },
@@ -684,6 +688,7 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
       h(Box, { width: "100%" },
         h(MultilineInput, {
           value: draft,
+          valueVersion: draftVersion,
           onChange: (next) => setDraft(next),
           onSubmit: (value) => submit(value),
           onCancel: () => {
@@ -715,6 +720,10 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
           interactive,
           placeholder: "",
           promptPrefix: targetAgent ? `›@${getAgentLabel(targetAgent)} ` : "› ",
+          // The agents footer is rendered below the input. Matching chat's
+          // IME parking contract keeps the hardware cursor aligned with the
+          // inverse caret instead of drifting to the bottom of the frame.
+          linesBelowInput: 1,
         }),
       ),
       h(Box, { width: "100%" },

package/src/ui/{components → ink}/agentMirror.js

@@ -15,10 +15,10 @@
  * Returns a stop() function that the caller invokes on exit.
  */
 
-const { createAgentSockets } = require("../../chat/agentSockets");
-const { loadInternalAgentLogHistory } = require("../../chat/internalAgentLogHistory");
-const { IPC_REQUEST_TYPES, IPC_RESPONSE_TYPES } = require("../../shared/eventContract");
-const { getUfooPaths } = require("../../ufoo/paths");
+const { createAgentSockets } = require("../../app/chat/agentSockets");
+const { loadInternalAgentLogHistory } = require("../../app/chat/internalAgentLogHistory");
+const { IPC_REQUEST_TYPES, IPC_RESPONSE_TYPES } = require("../../runtime/contracts/eventContract");
+const { getUfooPaths } = require("../../coordination/state/paths");
 const os = require("os");
 const path = require("path");
 const readline = require("readline");
@@ -217,10 +217,8 @@ function startAgentMirror({
   const cols = stdout.columns || 80;
   const rows = stdout.rows || 24;
 
-  // Mirror the lookup that runChatBlessed uses:
-  // <bus-queues-dir>/<safeName>/inject.sock. We sanitise the agent id the
-  // same way so a daemon launched by either TUI is reachable from the
-  // other.
+  // Mirror the daemon socket lookup:
+  // <bus-queues-dir>/<safeName>/inject.sock.
   const safeName = String(agentId || "").replace(/[^A-Za-z0-9_-]/g, "_");
   const sockPath = path.join(
     getUfooPaths(projectRoot || process.cwd()).busQueuesDir,
@@ -247,7 +245,7 @@ function startAgentMirror({
   // Clear screen + reserve a 1-line bar at the bottom for our exit hint.
   writeOut("\x1b[2J\x1b[H");
   writeOut(`\x1b[1;${Math.max(1, rows - 1)}r`);
-  writeOut(`\x1b[${rows};1H\x1b[7m esc \x1b[0m return to chat · attached to ${agentId}`);
+  writeOut(`\x1b[${rows};1H\x1b[7m esc esc \x1b[0m return to chat · attached to ${agentId}`);
   writeOut("\x1b[H");
 
   sockets.connectOutput(sockPath);
@@ -259,23 +257,30 @@ function startAgentMirror({
   if (typeof stdin.setRawMode === "function") stdin.setRawMode(true);
   stdin.resume();
 
+  let escCount = 0;
+  let escTimer = null;
+
   const onData = (chunk) => {
     if (stopped) return;
-    // Esc on its own (single 0x1b byte, no follow-up) exits the mirror.
-    // We can't perfectly distinguish a bare Esc from the start of an
-    // arrow-key sequence; the convention here is "Esc + nothing within
-    // 50ms means leave". Anything else gets forwarded as-is.
     if (chunk.length === 1 && chunk[0] === 0x1b) {
-      setTimeout(() => {
-        if (!stopped && pendingEsc === chunk) stop();
-      }, 50);
-      pendingEsc = chunk;
+      escCount += 1;
+      if (escCount >= 2) {
+        clearTimeout(escTimer);
+        escCount = 0;
+        stop();
+        return;
+      }
+      escTimer = setTimeout(() => { escCount = 0; }, 300);
+      return;
+    }
+    if (escCount > 0) {
+      clearTimeout(escTimer);
+      escCount = 0;
+      sockets.sendRaw(Buffer.concat([Buffer.from([0x1b]), chunk]));
       return;
     }
-    pendingEsc = null;
     sockets.sendRaw(chunk);
   };
-  let pendingEsc = null;
 
   const onResize = () => {
     if (stopped) return;

package/src/ui/{components → ink}/chatReducer.js

@@ -42,6 +42,7 @@ const DASHBOARD_VIEWS = ["projects", "agents", "mode", "provider", "cron"];
 const DEFAULT_PROVIDER_OPTIONS = [
   { label: "codex", value: "codex-cli" },
   { label: "claude", value: "claude-cli" },
+  { label: "agy", value: "agy-cli" },
 ];
 function projectRootOf(row = {}) {
   return String((row && (row.root || row.project_root || row.projectRoot)) || "");
@@ -68,9 +69,10 @@ function createInitialState({ banner = [], globalMode = false, globalScope = "co
     selectedProjectIndex: -1,
     selectedProjectRoot: "",
     projectListWindowStart: 0,
+    emptyProjectsDownArmed: false,
     activeProjectRoot: "",
-    modeOptions: ["auto", "host", "terminal", "tmux", "internal-pty", "internal"],
-    selectedModeIndex: Math.max(0, ["auto", "host", "terminal", "tmux", "internal-pty", "internal"].indexOf(initialLaunchMode)),
+    modeOptions: ["auto", "host", "terminal", "tmux", "internal"],
+    selectedModeIndex: Math.max(0, ["auto", "host", "terminal", "tmux", "internal"].indexOf(initialLaunchMode)),
     providerOptions: DEFAULT_PROVIDER_OPTIONS,
     selectedProviderIndex,
     cronTasks: [],
@@ -132,11 +134,27 @@ function reducer(state, action) {
     case "draft/clear":
       return { ...state, draft: "" };
     case "focus/toggle":
-      return { ...state, focusMode: state.focusMode === "input" ? "dashboard" : "input" };
+      return {
+        ...state,
+        focusMode: state.focusMode === "input" ? "dashboard" : "input",
+        emptyProjectsDownArmed: state.focusMode === "input" ? state.emptyProjectsDownArmed : false,
+      };
     case "focus/set":
-      return { ...state, focusMode: action.mode === "dashboard" ? "dashboard" : "input" };
-    case "view/set":
-      return { ...state, dashboardView: action.view };
+      return {
+        ...state,
+        focusMode: action.mode === "dashboard" ? "dashboard" : "input",
+        emptyProjectsDownArmed: action.mode === "dashboard" ? state.emptyProjectsDownArmed : false,
+      };
+    case "view/set": {
+      const view = action.view;
+      const inAgentsView = view === "agents";
+      return {
+        ...state,
+        dashboardView: view,
+        agentSelectionMode: inAgentsView && state.focusMode === "dashboard" && state.selectedAgentIndex >= 0,
+        emptyProjectsDownArmed: view === "projects" ? state.emptyProjectsDownArmed : false,
+      };
+    }
     case "view/cycle": {
       const i = DASHBOARD_VIEWS.indexOf(state.dashboardView);
       const direction = action.direction === "left" ? -1 : 1;
@@ -204,6 +222,7 @@ function reducer(state, action) {
         selectedProjectRoot: selectedIndex >= 0 ? selectedRoot : "",
         selectedProjectIndex: selectedIndex,
         activeProjectRoot: action.activeProjectRoot || state.activeProjectRoot,
+        emptyProjectsDownArmed: list.length === 0 ? state.emptyProjectsDownArmed : false,
       };
     }
     case "projects/select":
@@ -211,9 +230,12 @@ function reducer(state, action) {
         ...state,
         selectedProjectIndex: action.index,
         selectedProjectRoot: String(action.projectRoot || projectRootOf(state.projects[action.index]) || ""),
+        emptyProjectsDownArmed: false,
       };
     case "projects/clearSelection":
-      return { ...state, selectedProjectIndex: -1, selectedProjectRoot: "" };
+      return { ...state, selectedProjectIndex: -1, selectedProjectRoot: "", emptyProjectsDownArmed: false };
+    case "projects/armEmptyDown":
+      return { ...state, emptyProjectsDownArmed: true };
     case "projects/window":
       return { ...state, projectListWindowStart: Math.max(0, action.windowStart | 0) };
     case "scope/set":

package/src/bus/messageMeta.js

@@ -1,52 +0,0 @@
-"use strict";
-
-const INJECTION_MODES = {
-  IMMEDIATE: "immediate",
-  QUEUED: "queued",
-};
-
-function normalizeInjectionMode(value, fallback = INJECTION_MODES.IMMEDIATE) {
-  const raw = String(value || "").trim().toLowerCase();
-  if (raw === INJECTION_MODES.QUEUED) return INJECTION_MODES.QUEUED;
-  if (raw === INJECTION_MODES.IMMEDIATE) return INJECTION_MODES.IMMEDIATE;
-  return fallback;
-}
-
-function normalizeMessageSource(value) {
-  const raw = String(value || "").trim();
-  return raw || "";
-}
-
-function buildMessageData(message, options = {}) {
-  const base = options && typeof options.data === "object" && options.data
-    ? { ...options.data }
-    : {};
-  const data = { ...base, message };
-  data.injection_mode = normalizeInjectionMode(
-    options.injectionMode || data.injection_mode,
-    INJECTION_MODES.IMMEDIATE,
-  );
-  const source = normalizeMessageSource(options.source || data.source);
-  if (source) {
-    data.source = source;
-  } else {
-    delete data.source;
-  }
-  return data;
-}
-
-function getInjectionModeFromEvent(evt, fallback = INJECTION_MODES.IMMEDIATE) {
-  const data = evt && typeof evt.data === "object" && evt.data ? evt.data : {};
-  return normalizeInjectionMode(
-    data.injection_mode || evt?.injection_mode,
-    fallback,
-  );
-}
-
-module.exports = {
-  INJECTION_MODES,
-  normalizeInjectionMode,
-  normalizeMessageSource,
-  buildMessageData,
-  getInjectionModeFromEvent,
-};