@qwen-code/qwen-code 0.22.0 → 0.22.2-preview.0

package/chunks/{dist-ESS34DHC.js → dist-6H6RZ5H6.js}

@@ -11,11 +11,11 @@ import {
   sendMessage,
   sendTyping,
   uploadToCdn
-} from "./chunk-ZLCT4C5A.js";
+} from "./chunk-MZS7GEC7.js";
 import {
   ChannelBase,
   isTerminalTaskLifecycleType
-} from "./chunk-AW27A43Y.js";
+} from "./chunk-E55H6BZ7.js";
 import "./chunk-IW6RQPQB.js";
 import "./chunk-CQ35AJ4Z.js";
 import {

package/chunks/{dist-LZO24N3E.js → dist-7CKN54NL.js}

@@ -3,7 +3,7 @@
 import {
   ChannelBase,
   isTerminalTaskLifecycleType
-} from "./chunk-AW27A43Y.js";
+} from "./chunk-E55H6BZ7.js";
 import "./chunk-IW6RQPQB.js";
 import {
   require_abort_controller,

package/chunks/{dist-5EV2G6MC.js → dist-DJBNNPLN.js}

@@ -6,7 +6,7 @@ import {
 import "./chunk-7E7UCJHS.js";
 import {
   PollingChannelBase
-} from "./chunk-AW27A43Y.js";
+} from "./chunk-E55H6BZ7.js";
 import "./chunk-IW6RQPQB.js";
 import {
   external_exports

package/chunks/{dist-J6P3C52Z.js → dist-FVJZSIO4.js}

@@ -11,7 +11,7 @@ import {
   sanitizePromptText,
   sanitizeSenderName,
   truncateCodePoints
-} from "./chunk-AW27A43Y.js";
+} from "./chunk-E55H6BZ7.js";
 import "./chunk-IW6RQPQB.js";
 import "./chunk-CQ35AJ4Z.js";
 import {
@@ -469,6 +469,21 @@ var QQChannel = class _QQChannel extends ChannelBase {
   _reconnectId = 0;
   blockStreaming = false;
   flushedSessions = /* @__PURE__ */ new Set();
+  /**
+   * Sessions with a prompt turn currently in flight, tracked via
+   * onPromptStart/onPromptEnd.
+   *
+   * This is the discriminator the cron textChunk handler uses to tell
+   * "prompt-response chunk" from "cron/non-prompt chunk". streamState
+   * cannot serve that role (#6094): it is never populated when
+   * blockStreaming is 'on' (onResponseChunk early-returns), so prompt
+   * chunks leak into cronBuffer; and a residual entry from a finished
+   * turn's unsettled flush silently blocks cron delivery. This set is
+   * reliable because ChannelBase always brackets a prompt turn with
+   * onPromptStart and onPromptEnd (onPromptEnd runs in the prompt path's
+   * finally, even on error/cancel), independent of streaming config.
+   */
+  activePromptSessions = /* @__PURE__ */ new Set();
   qqStatePath;
   /**
    * Path to the global sessions.json managed by start.ts.
@@ -523,7 +538,7 @@ var QQChannel = class _QQChannel extends ChannelBase {
       }
       if (!wasInCronFlow)
         return;
-      if (this.streamState.has(sessionId))
+      if (this.activePromptSessions.has(sessionId))
         return;
       let entry = this.cronBuffer.get(sessionId);
       if (!entry) {
@@ -995,15 +1010,20 @@ var QQChannel = class _QQChannel extends ChannelBase {
     this.flushingSessions.clear();
     this.pendingStreamDelete.clear();
     this.flushedSessions.clear();
+    this.activePromptSessions.clear();
   }
   /**
-   * QQ Bot API V2 does not provide a typing indicator endpoint.
-   * ChannelBase calls these hooks to signal prompt start/end;
-   * they are intentionally no-ops for this channel.
+   * QQ Bot API V2 does not provide a typing indicator endpoint, but these
+   * hooks still maintain activePromptSessions — the cron textChunk
+   * discriminator (see activePromptSessions). ChannelBase always pairs the
+   * two calls per prompt turn (onPromptEnd runs in the prompt path's
+   * finally, even on error/cancel).
    */
-  onPromptStart(_chatId, _sessionId, _messageId) {
+  onPromptStart(_chatId, sessionId, _messageId) {
+    this.activePromptSessions.add(sessionId);
   }
-  onPromptEnd(_chatId, _sessionId, _messageId) {
+  onPromptEnd(_chatId, sessionId, _messageId) {
+    this.activePromptSessions.delete(sessionId);
   }
   // ── Streaming (idle-flush with per-session buffers) ────────────
   onResponseChunk(chatId, chunk, sessionId) {
@@ -1218,6 +1238,7 @@ var QQChannel = class _QQChannel extends ChannelBase {
     this.flushingSessions.delete(sessionId);
     this.pendingStreamDelete.delete(sessionId);
     this.flushedSessions.delete(sessionId);
+    this.activePromptSessions.delete(sessionId);
     super.onSessionDied(sessionId);
   }
   // ── State Persistence (cross-server context continuation) ──────

package/chunks/{dist-K7IQB53U.js → dist-SATKXKUR.js}

@@ -8,7 +8,7 @@ import {
   sanitizeLogText,
   sanitizePromptText,
   truncateCodePoints
-} from "./chunk-AW27A43Y.js";
+} from "./chunk-E55H6BZ7.js";
 import "./chunk-IW6RQPQB.js";
 import "./chunk-CQ35AJ4Z.js";
 import {

package/chunks/{dist-ES6HNUW2.js → dist-TJUDJTCB.js}

@@ -11,8 +11,10 @@ import {
   ChannelBase,
   isTerminalTaskLifecycleType,
   sanitizeLogText,
-  sanitizeSenderName
-} from "./chunk-AW27A43Y.js";
+  sanitizePromptText,
+  sanitizeSenderName,
+  truncateUtf16Units
+} from "./chunk-E55H6BZ7.js";
 import "./chunk-IW6RQPQB.js";
 import "./chunk-CQ35AJ4Z.js";
 import "./chunk-DMTGGOSA.js";
@@ -7670,6 +7672,201 @@ var DingtalkInteractionPresenter = class {
 };
 
 // packages/channels/dingtalk/dist/DingtalkAdapter.js
+function nonEmptyString(value) {
+  if (typeof value !== "string")
+    return void 0;
+  const trimmed = value.trim();
+  return trimmed || void 0;
+}
+__name(nonEmptyString, "nonEmptyString");
+function parseJsonArray(value) {
+  if (Array.isArray(value))
+    return value;
+  if (typeof value !== "string")
+    return void 0;
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+__name(parseJsonArray, "parseJsonArray");
+function sanitizeChatRecordField(value) {
+  return sanitizePromptText(value).trim();
+}
+__name(sanitizeChatRecordField, "sanitizeChatRecordField");
+function bracketSafeChatRecordField(value) {
+  return sanitizeChatRecordField(value).replace(/[[\]]/g, " ").trim();
+}
+__name(bracketSafeChatRecordField, "bracketSafeChatRecordField");
+function startOfLineSafeChatRecordField(value) {
+  const sanitized = sanitizeChatRecordField(value);
+  if (!sanitized.startsWith("["))
+    return sanitized;
+  const deleted = new Uint8Array(sanitized.length);
+  let open = 0;
+  let close = 0;
+  for (; ; ) {
+    while (open < sanitized.length && (deleted[open] === 1 || /\s/.test(sanitized[open]))) {
+      open += 1;
+    }
+    if (sanitized[open] !== "[")
+      break;
+    let next = Math.max(close, open + 1);
+    while (next < sanitized.length && (deleted[next] === 1 || sanitized[next] !== "]")) {
+      next += 1;
+    }
+    if (next >= sanitized.length) {
+      deleted[open] = 1;
+      open += 1;
+      close = next;
+      continue;
+    }
+    deleted[open] = 1;
+    deleted[next] = 1;
+    open += 1;
+    close = next + 1;
+  }
+  const parts = [];
+  let cut = 0;
+  for (let i = 0; i < sanitized.length; i++) {
+    if (deleted[i] === 0)
+      continue;
+    if (i > cut)
+      parts.push(sanitized.slice(cut, i));
+    cut = i + 1;
+  }
+  parts.push(sanitized.slice(cut));
+  return parts.join("").trim();
+}
+__name(startOfLineSafeChatRecordField, "startOfLineSafeChatRecordField");
+var MAX_CHAT_RECORD_ENTRIES = 50;
+var MAX_CHAT_RECORD_CHARS = 4e3;
+var MAX_CHAT_RECORD_LINE_CHARS = 500;
+var MAX_QUOTED_CHAT_RECORD_CHARS = 500;
+var CHAT_RECORD_ENTRIES_LABEL = "[Chat record messages]";
+var CHAT_RECORD_HEADER_LEAD = /* @__PURE__ */ __name((title) => `[Chat record: ${title}] `, "CHAT_RECORD_HEADER_LEAD");
+var CHAT_RECORD_PART_GAP = 2;
+function announcedDrop(count) {
+  return `[${count} more message(s) not shown]`;
+}
+__name(announcedDrop, "announcedDrop");
+function chatRecordAnnouncementCost(lines) {
+  return lines.length > 0 ? announcedDrop(lines.length).length + 1 : 0;
+}
+__name(chatRecordAnnouncementCost, "chatRecordAnnouncementCost");
+function capChatRecordLines(lines, budget) {
+  const kept = [];
+  let dropped = 0;
+  let total = 0;
+  const spendable = budget - chatRecordAnnouncementCost(lines);
+  if (spendable < 0)
+    return [];
+  for (const [index, line] of lines.entries()) {
+    if (kept.length >= MAX_CHAT_RECORD_ENTRIES) {
+      dropped = lines.length - index;
+      break;
+    }
+    const boundedRaw = truncateUtf16Units(line, MAX_CHAT_RECORD_LINE_CHARS);
+    const bounded = boundedRaw === line ? line : `${boundedRaw} [truncated]`;
+    if (total + bounded.length > spendable) {
+      dropped = lines.length - index;
+      break;
+    }
+    kept.push(bounded);
+    total += bounded.length + 1;
+  }
+  if (dropped > 0)
+    kept.push(announcedDrop(dropped));
+  return kept;
+}
+__name(capChatRecordLines, "capChatRecordLines");
+function mediaTypePlaceholder(msgType, fileName) {
+  switch (msgType) {
+    case "picture":
+      return "[image]";
+    case "file": {
+      const name = bracketSafeChatRecordField(nonEmptyString(fileName) || "");
+      return `[file: ${name || "file"}]`;
+    }
+    case "audio":
+      return "[audio]";
+    case "video":
+      return "[video]";
+    default:
+      return void 0;
+  }
+}
+__name(mediaTypePlaceholder, "mediaTypePlaceholder");
+function formatChatRecordEntryBody(record) {
+  const rawContent = record["content"];
+  const content = rawContent && typeof rawContent === "object" ? rawContent : void 0;
+  const body = nonEmptyString(record["text"]) || nonEmptyString(rawContent) || nonEmptyString(content?.["text"]) || nonEmptyString(record["message"]) || nonEmptyString(record["body"]);
+  if (body)
+    return sanitizeChatRecordField(body) || "[message]";
+  const msgType = nonEmptyString(record["msgType"]) || nonEmptyString(record["msgtype"]);
+  const safeMsgType = msgType ? bracketSafeChatRecordField(msgType) : "";
+  return mediaTypePlaceholder(msgType, content?.["fileName"]) ?? // Record-specific fallback: name the type when DingTalk sends one we do
+  // not model, so the model sees *something* arrived rather than a gap.
+  // The name is record content like every other field here, so it is
+  // neutralized before it goes inside the brackets.
+  (safeMsgType ? `[${safeMsgType}]` : "[message]");
+}
+__name(formatChatRecordEntryBody, "formatChatRecordEntryBody");
+function describeChatRecordKeys(content) {
+  if (!content || typeof content !== "object")
+    return "none";
+  const keys = Object.keys(content);
+  return keys.length > 0 ? keys.join(",") : "none";
+}
+__name(describeChatRecordKeys, "describeChatRecordKeys");
+function formatChatRecord(content, budget = MAX_CHAT_RECORD_CHARS) {
+  const title = nonEmptyString(content?.title);
+  const rawSummary = nonEmptyString(content?.summary);
+  const parsedSummary = parseJsonArray(rawSummary);
+  const summaryLines = parsedSummary ? parsedSummary.map((item) => startOfLineSafeChatRecordField(nonEmptyString(item) || "") || "") : rawSummary?.split("\n").map((line) => startOfLineSafeChatRecordField(nonEmptyString(line) || "")) || [];
+  const rawEntries = content?.chatRecord ?? content?.records ?? content?.messages;
+  const entries = parseJsonArray(rawEntries);
+  const recordLines = Array.isArray(entries) ? entries.flatMap((entry, index) => {
+    if (typeof entry === "string") {
+      const body = nonEmptyString(entry);
+      if (!body)
+        return [];
+      return [`Unknown: ${formatChatRecordEntryBody({ text: body })}`];
+    }
+    if (!entry || typeof entry !== "object")
+      return [];
+    const record = entry;
+    const summarySender = summaryLines.length === entries.length ? nonEmptyString(summaryLines[index]?.match(/^([^:：]+)[:：]/)?.[1]) : void 0;
+    const rawSender = nonEmptyString(record["senderName"]) || nonEmptyString(record["senderNick"]) || nonEmptyString(record["sender"]) || summarySender || nonEmptyString(record["senderId"]);
+    const sender = rawSender && bracketSafeChatRecordField(rawSender) || "Unknown";
+    return [`${sender}: ${formatChatRecordEntryBody(record)}`];
+  }) : [];
+  const entriesFloor = recordLines.length > 0 ? CHAT_RECORD_ENTRIES_LABEL.length + 1 + chatRecordAnnouncementCost(recordLines) : 0;
+  const headerBudget = Math.max(budget - CHAT_RECORD_PART_GAP - entriesFloor, 0);
+  const summaryDisplayLines = summaryLines.filter(Boolean);
+  const safeTitle = title ? truncateUtf16Units(bracketSafeChatRecordField(title), Math.max(Math.min(MAX_CHAT_RECORD_LINE_CHARS, headerBudget - CHAT_RECORD_HEADER_LEAD("").length - chatRecordAnnouncementCost(summaryDisplayLines)), 0)) || void 0 : void 0;
+  const headerLead = CHAT_RECORD_HEADER_LEAD(safeTitle || "untitled");
+  const summary = capChatRecordLines(summaryDisplayLines, Math.max(headerBudget - headerLead.length, 0)).join("\n");
+  const parts = [];
+  if (summary) {
+    parts.push(`${headerLead}${summary}`);
+  } else if (safeTitle) {
+    parts.push(`[Chat record: ${safeTitle}]`);
+  }
+  const spent = parts.reduce((used, part) => used + part.length + CHAT_RECORD_PART_GAP, 0);
+  const boundedLines = capChatRecordLines(recordLines, Math.max(budget - spent - CHAT_RECORD_ENTRIES_LABEL.length - 1, 0));
+  if (boundedLines.length > 0) {
+    parts.push(`${CHAT_RECORD_ENTRIES_LABEL}
+${boundedLines.join("\n")}`);
+  }
+  return {
+    text: parts.join("\n\n"),
+    entriesDropped: rawEntries !== void 0 && recordLines.length === 0
+  };
+}
+__name(formatChatRecord, "formatChatRecord");
 var DEDUP_TTL_MS = 5 * 60 * 1e3;
 var ACK_REACTION_NAME = "\u{1F440}";
 var ACK_EMOTION_ID = "2659900";
@@ -8580,8 +8777,32 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     return { isReplyToBot: false };
   }
   /**
-   * Build a text summary from a repliedMsg, handling text, richText, and
-   * media message types with placeholders.
+   * Warn once when a chat-record payload yields nothing to show the model.
+   * Both chat-record paths degrade silently otherwise — `parseJsonArray`
+   * swallows JSON errors, the top-level path falls back to `(chat record)`
+   * and the replied path to an empty quote — matching this file's convention
+   * of logging degraded paths (`onDownStream`, `onMessage`).
+   */
+  warnEmptyChatRecord(content) {
+    process.stderr.write(`[DingTalk:${this.name}] chat record had no readable content (content keys: ${sanitizeLogText(describeChatRecordKeys(content), 200)})
+`);
+  }
+  /**
+   * The partial degradation the empty-record warning cannot see: a title or
+   * summary rendered, so the result is non-empty, but the entries key that
+   * arrived produced no lines at all (an object encoding such as
+   * `{"list":[...]}`, a non-array, or a present-but-unusable first alias).
+   * Every forwarded message is dropped and the user reports only that "the bot
+   * cannot see forwarded messages"; without this line nothing in the log
+   * distinguishes that from model behaviour.
+   */
+  warnUnreadableChatRecordEntries(content) {
+    process.stderr.write(`[DingTalk:${this.name}] chat record summary rendered but no readable entries (content keys: ${sanitizeLogText(describeChatRecordKeys(content), 200)})
+`);
+  }
+  /**
+   * Build a text summary from a repliedMsg, handling text, richText, chat
+   * records, and media message types with placeholders.
    */
   summarizeRepliedContent(replied) {
     const msgType = replied.msgType;
@@ -8605,19 +8826,15 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
       if (summary)
         return summary;
     }
-    switch (msgType) {
-      case "picture":
-        return "[image]";
-      case "file":
-        return `[file: ${content?.fileName || "file"}]`;
-      case "audio":
-        return "[audio]";
-      case "video":
-        return "[video]";
-      default:
-        break;
+    if (msgType === "chatRecord") {
+      const { text, entriesDropped } = formatChatRecord(content, MAX_QUOTED_CHAT_RECORD_CHARS);
+      if (!text)
+        this.warnEmptyChatRecord(content);
+      else if (entriesDropped)
+        this.warnUnreadableChatRecordEntries(content);
+      return text;
     }
-    return "";
+    return mediaTypePlaceholder(msgType, content?.fileName) ?? "";
   }
   /**
    * Map a DingTalk message type to the media type used for downloads. Shared
@@ -8634,7 +8851,8 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   }
   /**
    * Extract text and media download codes from an incoming DingTalk message.
-   * Handles text, richText, picture, file, audio, and video message types.
+   * Handles text, richText, chat records, picture, file, audio, and video
+   * message types.
    */
   extractContent(data) {
     const msgtype = data.msgtype || "text";
@@ -8698,6 +8916,17 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
         placeholder: "(video)"
       };
     }
+    if (msgtype === "chatRecord") {
+      const { text, entriesDropped } = formatChatRecord(data.content);
+      if (!text)
+        this.warnEmptyChatRecord(data.content);
+      else if (entriesDropped)
+        this.warnUnreadableChatRecordEntries(data.content);
+      return {
+        text: text || "(chat record)",
+        downloadCodes: []
+      };
+    }
     return { text: data.text?.content?.trim() || "", downloadCodes: [] };
   }
   /**

package/chunks/{dist-VVQBOKDH.js → dist-UQUFZDIY.js}

@@ -10,7 +10,7 @@ import "./chunk-7E7UCJHS.js";
 import {
   ChannelBase,
   sanitizeLogText
-} from "./chunk-AW27A43Y.js";
+} from "./chunk-E55H6BZ7.js";
 import "./chunk-IW6RQPQB.js";
 import "./chunk-CQ35AJ4Z.js";
 import "./chunk-DMTGGOSA.js";

package/chunks/{dist-2OG3PGKO.js → dist-ZBVOXSKF.js}

@@ -4,11 +4,11 @@ import {
   require_axios,
   require_ws
 } from "./chunk-AVNATYLY.js";
+import "./chunk-XIQ5HQ2F.js";
+import "./chunk-K6KS3LTN.js";
 import {
   require_lib
 } from "./chunk-HMJ2P3SV.js";
-import "./chunk-XIQ5HQ2F.js";
-import "./chunk-K6KS3LTN.js";
 import "./chunk-7E7UCJHS.js";
 import {
   ChannelBase,
@@ -16,7 +16,7 @@ import {
   isChannelProactiveDeliveryError,
   isTerminalTaskLifecycleType,
   sanitizeSenderName
-} from "./chunk-AW27A43Y.js";
+} from "./chunk-E55H6BZ7.js";
 import "./chunk-IW6RQPQB.js";
 import "./chunk-CQ35AJ4Z.js";
 import {

package/chunks/earlyInputCapture-2EJKJET3.js

@@ -0,0 +1,109 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  getAndClearCapturedInput,
+  hasCapturedInput,
+  resetCaptureState,
+  startEarlyInputCapture,
+  stopAndGetCapturedInput,
+  stopEarlyInputCapture
+} from "./chunk-GNMJNDZE.js";
+import "./chunk-RUQBJS34.js";
+import "./chunk-LRLMDV5X.js";
+import "./chunk-LRKMQPMD.js";
+import "./chunk-LJZSMWOH.js";
+import "./chunk-H2MDBYLL.js";
+import "./chunk-JLGFGPZJ.js";
+import "./chunk-SKNVVYIJ.js";
+import "./chunk-UCSV2IZW.js";
+import "./chunk-T2HMXHYA.js";
+import "./chunk-3FSBMAYD.js";
+import "./chunk-XJS54K4A.js";
+import "./chunk-ZPJWUGCS.js";
+import "./chunk-ZWKGZB2K.js";
+import "./chunk-OX44MOAN.js";
+import "./chunk-D6XO27Z5.js";
+import "./chunk-GOFAQQZA.js";
+import "./chunk-5M6IDOMF.js";
+import "./chunk-TWPJO254.js";
+import "./chunk-CQ35AJ4Z.js";
+import "./chunk-3UZCLCXR.js";
+import "./chunk-TOF4UZHH.js";
+import "./chunk-O3BUXIPM.js";
+import "./chunk-ZLTEQYNC.js";
+import "./chunk-6PVPNMXU.js";
+import "./chunk-AYVIGUUK.js";
+import "./chunk-IRH27ZC2.js";
+import "./chunk-QHWCP53L.js";
+import "./chunk-JECO75XD.js";
+import "./chunk-O6GEWCJA.js";
+import "./chunk-T26EAKDL.js";
+import "./chunk-LJP2BBMK.js";
+import "./chunk-CPBF7KYF.js";
+import "./chunk-5Y2JCJAH.js";
+import "./chunk-T2CRBIDJ.js";
+import "./chunk-77TOMRBG.js";
+import "./chunk-DEYPMJPD.js";
+import "./chunk-T6OODF2U.js";
+import "./chunk-27ONXAFY.js";
+import "./chunk-ZEADBZLO.js";
+import "./chunk-FN5C6C7G.js";
+import "./chunk-BVE5EMIG.js";
+import "./chunk-MLXTMF7H.js";
+import "./chunk-NAVJD2PQ.js";
+import "./chunk-FVDQ5E67.js";
+import "./chunk-V3GINY6K.js";
+import "./chunk-QHMLYMMS.js";
+import "./chunk-SDVF6A42.js";
+import "./chunk-P3QQPMQA.js";
+import "./chunk-ILPXSKGQ.js";
+import "./chunk-VNOVK4I7.js";
+import "./chunk-SAH4BD2J.js";
+import "./chunk-ZKAZP2ZG.js";
+import "./chunk-DP7LABIB.js";
+import "./chunk-S6LOFUVP.js";
+import "./chunk-2LD5U7Q3.js";
+import "./chunk-DJ2GSRLV.js";
+import "./chunk-I6VVOZDK.js";
+import "./chunk-K2OJUPOE.js";
+import "./chunk-CFKIH3D3.js";
+import "./chunk-EB4VDXNI.js";
+import "./chunk-FJWICLG7.js";
+import "./chunk-UX3IFLJM.js";
+import "./chunk-YRLW2MSX.js";
+import "./chunk-VGC4I5JJ.js";
+import "./chunk-WBT3STGU.js";
+import "./chunk-PVBT5QPD.js";
+import "./chunk-IPQA4SR5.js";
+import "./chunk-WZAD4ZNJ.js";
+import "./chunk-FPGTNKCP.js";
+import "./chunk-SLEWBQWM.js";
+import "./chunk-4X5GYZFO.js";
+import "./chunk-XZA32HII.js";
+import "./chunk-7QGEJI7M.js";
+import "./chunk-GTUKW3I6.js";
+import "./chunk-HHJLM3WQ.js";
+import "./chunk-6US7BF3G.js";
+import "./chunk-74TONY4F.js";
+import "./chunk-VL4YX3FH.js";
+import "./chunk-JUIJ3FXC.js";
+import "./chunk-E6FGMDFQ.js";
+import "./chunk-AQ37AY7B.js";
+import "./chunk-RRKNX553.js";
+import "./chunk-KOJ6MHD5.js";
+import "./chunk-2NNTE2ED.js";
+import "./chunk-75DOP5OR.js";
+import "./chunk-DMTGGOSA.js";
+import "./chunk-YQ3U5MUC.js";
+import "./chunk-AMDSOFFV.js";
+import "./chunk-TBWQLLFO.js";
+import "./chunk-5O2XNYP6.js";
+import "./chunk-J2S4EL5Y.js";
+export {
+  getAndClearCapturedInput,
+  hasCapturedInput,
+  resetCaptureState,
+  startEarlyInputCapture,
+  stopAndGetCapturedInput,
+  stopEarlyInputCapture
+};