@qwen-code/qwen-code 0.22.0 → 0.22.1

package/chunks/{chunk-IWOWEENB.js → chunk-WBT3STGU.js}

@@ -1,15 +1,11 @@
 // Force strict mode and setup for ESM
 "use strict";
-import {
-  PIPELINE_IMAGE_MIME_TYPES,
-  estimateTextTokens
-} from "./chunk-YHC2EYYG.js";
 import {
   createDebugLogger,
   getErrorMessage,
   isAbortError,
   isNodeError
-} from "./chunk-A5F2YNO6.js";
+} from "./chunk-2NNTE2ED.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -5746,7 +5742,7 @@ var require_lib = __commonJS({
   }
 });
 
-// packages/core/src/memory/const.ts
+// packages/core/src/utils/memory-constants.ts
 init_esbuild_shims();
 var DEFAULT_CONTEXT_FILENAME = "QWEN.md";
 var AGENT_CONTEXT_FILENAME = "AGENTS.md";
@@ -5792,6 +5788,47 @@ import { execFile } from "node:child_process";
 import { mkdtemp, readdir, readFile, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+
+// packages/core/src/utils/request-tokenizer/textTokenizer.ts
+init_esbuild_shims();
+var NON_ASCII_RE = /[\u0080-\uffff]/;
+var TOKEN_ESTIMATE_UNITS_PER_TOKEN = 20;
+function estimateTextTokens(text) {
+  if (!text || text.length === 0) {
+    return 0;
+  }
+  if (!NON_ASCII_RE.test(text)) {
+    return Math.ceil(text.length / 4);
+  }
+  const nonAsciiChars = countNonAsciiChars(text);
+  const asciiChars = text.length - nonAsciiChars;
+  return Math.ceil(asciiChars / 4 + nonAsciiChars * 1.1);
+}
+__name(estimateTextTokens, "estimateTextTokens");
+function estimateTextTokenUnits(text) {
+  if (!text || text.length === 0) {
+    return 0;
+  }
+  if (!NON_ASCII_RE.test(text)) {
+    return text.length * 5;
+  }
+  const nonAsciiChars = countNonAsciiChars(text);
+  const asciiChars = text.length - nonAsciiChars;
+  return asciiChars * 5 + nonAsciiChars * 22;
+}
+__name(estimateTextTokenUnits, "estimateTextTokenUnits");
+function countNonAsciiChars(text) {
+  let count = 0;
+  for (let i = 0; i < text.length; i++) {
+    if (text.charCodeAt(i) >= 128) {
+      count++;
+    }
+  }
+  return count;
+}
+__name(countNonAsciiChars, "countNonAsciiChars");
+
+// packages/core/src/utils/pdf.ts
 var MAX_PDF_TEXT_OUTPUT_CHARS = 1e5;
 var PDF_FULL_TEXT_PAGE_LIMIT = 10;
 var PDF_MAX_PAGES_PER_READ = 20;
@@ -6147,6 +6184,227 @@ async function renderPDFPagesToImages(filePath, options) {
 }
 __name(renderPDFPagesToImages, "renderPDFPagesToImages");
 
+// packages/core/src/utils/binary-content.ts
+init_esbuild_shims();
+import { mkdir, writeFile } from "node:fs/promises";
+import * as path from "node:path";
+var BINARY_APPLICATION_TYPES = /* @__PURE__ */ new Set([
+  "application/pdf",
+  "application/zip",
+  "application/gzip",
+  "application/x-gzip",
+  "application/octet-stream",
+  "application/msword",
+  "application/vnd.ms-excel",
+  "application/vnd.ms-powerpoint",
+  "application/x-tar",
+  "application/x-7z-compressed",
+  "application/x-rar-compressed",
+  "application/vnd.rar",
+  "application/wasm",
+  "application/java-archive"
+]);
+function isBinaryContentType(contentType) {
+  if (!contentType) return false;
+  const mt = (contentType.split(";")[0] ?? "").trim().toLowerCase();
+  if (mt.startsWith("text/")) return false;
+  if (mt.endsWith("+json") || mt.endsWith("+xml")) return false;
+  if (mt.startsWith("image/") || mt.startsWith("audio/") || mt.startsWith("video/") || mt.startsWith("font/")) {
+    return true;
+  }
+  if (BINARY_APPLICATION_TYPES.has(mt)) return true;
+  if (mt.startsWith("application/vnd.openxmlformats")) return true;
+  if (mt.startsWith("application/vnd.oasis.opendocument")) return true;
+  return false;
+}
+__name(isBinaryContentType, "isBinaryContentType");
+var MIME_EXTENSIONS = /* @__PURE__ */ new Map([
+  ["application/pdf", "pdf"],
+  ["application/zip", "zip"],
+  [
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    "docx"
+  ],
+  ["application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "xlsx"],
+  [
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    "pptx"
+  ],
+  ["application/msword", "doc"],
+  ["application/vnd.ms-excel", "xls"],
+  ["application/vnd.ms-powerpoint", "ppt"],
+  ["application/gzip", "gz"],
+  ["application/x-gzip", "gz"],
+  ["application/x-tar", "tar"],
+  ["application/x-7z-compressed", "7z"],
+  ["application/x-rar-compressed", "rar"],
+  ["application/vnd.rar", "rar"],
+  ["application/wasm", "wasm"],
+  ["application/java-archive", "jar"],
+  ["audio/mpeg", "mp3"],
+  ["audio/wav", "wav"],
+  ["audio/ogg", "ogg"],
+  ["video/mp4", "mp4"],
+  ["video/webm", "webm"],
+  ["image/png", "png"],
+  ["image/jpeg", "jpg"],
+  ["image/gif", "gif"],
+  ["image/webp", "webp"],
+  ["image/svg+xml", "svg"]
+]);
+function extensionForMimeType(mimeType) {
+  if (!mimeType) return "bin";
+  const mt = (mimeType.split(";")[0] ?? "").trim().toLowerCase();
+  return MIME_EXTENSIONS.get(mt) ?? "bin";
+}
+__name(extensionForMimeType, "extensionForMimeType");
+var KNOWN_EXTENSIONS = /* @__PURE__ */ new Set([...MIME_EXTENSIONS.values(), "jpeg", "bin"]);
+function extensionFromFilename(name) {
+  if (!name) return void 0;
+  const ext = name.split(".").pop()?.trim().toLowerCase();
+  return ext && ext !== name && KNOWN_EXTENSIONS.has(ext) ? ext : void 0;
+}
+__name(extensionFromFilename, "extensionFromFilename");
+function filenameFromContentDisposition(contentDisposition) {
+  const star = /filename\*\s*=\s*[^']*'[^']*'([^;]+)/i.exec(contentDisposition);
+  if (star?.[1]) {
+    try {
+      return decodeURIComponent(star[1].trim());
+    } catch {
+      return star[1].trim();
+    }
+  }
+  const plain = /filename\s*=\s*"?([^";]+)"?/i.exec(contentDisposition);
+  return plain?.[1]?.trim();
+}
+__name(filenameFromContentDisposition, "filenameFromContentDisposition");
+function sniffFileKind(bytes, contentType, contentDisposition, url) {
+  const dispositionExt = extensionFromFilename(
+    filenameFromContentDisposition(contentDisposition)
+  );
+  let urlExt;
+  try {
+    urlExt = extensionFromFilename(new URL(url).pathname.split("/").pop());
+  } catch {
+    urlExt = void 0;
+  }
+  if (bytes.length >= 5 && bytes.subarray(0, 5).toString("latin1") === "%PDF-") {
+    return {
+      extension: "pdf",
+      mimeType: "application/pdf",
+      magicMatched: true,
+      extensionSource: "magic"
+    };
+  }
+  if (bytes.length >= 4 && bytes[0] === 80 && bytes[1] === 75 && bytes[2] === 3 && bytes[3] === 4) {
+    const zipHint = dispositionExt ?? urlExt ?? extensionForMimeType(contentType);
+    const refined = zipHint && ["docx", "xlsx", "pptx", "jar"].includes(zipHint) ? zipHint : "zip";
+    return {
+      extension: refined,
+      mimeType: contentType || "application/zip",
+      magicMatched: true,
+      extensionSource: "magic"
+    };
+  }
+  if (bytes.length >= 2 && bytes[0] === 31 && bytes[1] === 139) {
+    return {
+      extension: "gz",
+      mimeType: "application/gzip",
+      magicMatched: true,
+      extensionSource: "magic"
+    };
+  }
+  if (bytes.length >= 7 && bytes.subarray(0, 4).toString("latin1") === "Rar!" && bytes[4] === 26 && bytes[5] === 7) {
+    return {
+      extension: "rar",
+      mimeType: "application/vnd.rar",
+      magicMatched: true,
+      extensionSource: "magic"
+    };
+  }
+  if (bytes.length >= 8 && bytes[0] === 137 && bytes.subarray(1, 4).toString("latin1") === "PNG") {
+    return {
+      extension: "png",
+      mimeType: "image/png",
+      magicMatched: true,
+      extensionSource: "magic"
+    };
+  }
+  if (bytes.length >= 3 && bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) {
+    return {
+      extension: "jpg",
+      mimeType: "image/jpeg",
+      magicMatched: true,
+      extensionSource: "magic"
+    };
+  }
+  if (bytes.length >= 4 && bytes.subarray(0, 4).toString("latin1") === "GIF8") {
+    return {
+      extension: "gif",
+      mimeType: "image/gif",
+      magicMatched: true,
+      extensionSource: "magic"
+    };
+  }
+  if (bytes.length >= 12 && bytes.subarray(0, 4).toString("latin1") === "RIFF" && bytes.subarray(8, 12).toString("latin1") === "WEBP") {
+    return {
+      extension: "webp",
+      mimeType: "image/webp",
+      magicMatched: true,
+      extensionSource: "magic"
+    };
+  }
+  const nameExt = dispositionExt ?? urlExt;
+  if (nameExt) {
+    return {
+      extension: nameExt,
+      mimeType: contentType,
+      magicMatched: false,
+      extensionSource: "name"
+    };
+  }
+  const mimeExt = extensionForMimeType(contentType);
+  return {
+    extension: mimeExt,
+    mimeType: contentType,
+    magicMatched: false,
+    extensionSource: mimeExt !== "bin" ? "mime" : "fallback"
+  };
+}
+__name(sniffFileKind, "sniffFileKind");
+function looksLikeText(bytes) {
+  const window = bytes.subarray(0, 8192);
+  if (window.includes(0)) return false;
+  const decoded = new TextDecoder("utf-8").decode(window);
+  let bad = 0;
+  for (let i = 0; i < decoded.length; i++) {
+    if (decoded[i] === "\uFFFD" && ++bad > 2) return false;
+  }
+  return true;
+}
+__name(looksLikeText, "looksLikeText");
+async function persistBinaryContent(bytes, ext, dir, persistId) {
+  const filepath = path.join(dir, `${persistId}.${ext}`);
+  try {
+    await mkdir(dir, { recursive: true, mode: 448 });
+    await writeFile(filepath, bytes, { mode: 384 });
+  } catch (error) {
+    return { error: error instanceof Error ? error.message : String(error) };
+  }
+  return { filepath, size: bytes.length, ext };
+}
+__name(persistBinaryContent, "persistBinaryContent");
+function formatByteSize(sizeInBytes) {
+  const kb = sizeInBytes / 1024;
+  if (kb < 1) return `${sizeInBytes} bytes`;
+  const fmt = /* @__PURE__ */ __name((n) => n.toFixed(1).replace(/\.0$/, ""), "fmt");
+  if (kb < 1024) return `${fmt(kb)}KB`;
+  const mb = kb / 1024;
+  if (mb < 1024) return `${fmt(mb)}MB`;
+  return `${fmt(mb / 1024)}GB`;
+}
+__name(formatByteSize, "formatByteSize");
+
 // packages/core/src/utils/notebook.ts
 init_esbuild_shims();
 import fs from "node:fs";
@@ -6639,7 +6897,7 @@ __name(renderNormalizedImageCrop, "renderNormalizedImageCrop");
 init_esbuild_shims();
 import fs3 from "node:fs";
 import fsPromises from "node:fs/promises";
-import path2 from "node:path";
+import path3 from "node:path";
 
 // packages/core/node_modules/mime/dist/src/index_lite.js
 init_esbuild_shims();
@@ -7063,12 +7321,12 @@ var Mime = class {
     }
     return this;
   }
-  getType(path3) {
-    if (typeof path3 !== "string")
+  getType(path4) {
+    if (typeof path4 !== "string")
       return null;
-    const last = path3.replace(/^.*[/\\]/s, "").toLowerCase();
+    const last = path4.replace(/^.*[/\\]/s, "").toLowerCase();
     const ext = last.replace(/^.*\./s, "").toLowerCase();
-    const hasPath = last.length < path3.length;
+    const hasPath = last.length < path4.length;
     const hasDot = ext.length < last.length - 1;
     if (!hasDot && hasPath)
       return null;
@@ -7138,7 +7396,7 @@ __name(loadIconvLite, "loadIconvLite");
 
 // packages/core/src/utils/ignorePatterns.ts
 init_esbuild_shims();
-import path from "node:path";
+import path2 from "node:path";
 var COMMON_IGNORE_PATTERNS = [
   "**/node_modules/**",
   "**/.git/**",
@@ -7277,7 +7535,7 @@ function extractExtensionsFromPatterns(patterns) {
         return inner.split(",").map((ext) => `.${ext.trim()}`).filter((ext) => ext !== ".");
       }
       if (extPart.startsWith(".") && !extPart.includes("/") && !extPart.includes("{") && !extPart.includes("}")) {
-        const extracted = path.extname(`dummy${extPart}`);
+        const extracted = path2.extname(`dummy${extPart}`);
         const result = extracted || extPart;
         return result && result !== "." && !result.substring(1).includes(".") ? [result] : [];
       }
@@ -7411,7 +7669,7 @@ function detectEncodingFromBuffer(buffer) {
 }
 __name(detectEncodingFromBuffer, "detectEncodingFromBuffer");
 
-// packages/core/src/services/visionBridge/vision-bridge-constants.ts
+// packages/core/src/utils/vision-bridge-constants.ts
 init_esbuild_shims();
 var VISION_BRIDGE_MAX_IMAGES = 4;
 var VISION_BRIDGE_MAX_IMAGE_BASE64_BYTES = Math.floor(
@@ -7907,6 +8165,43 @@ function detectLineEndingFromContent(content) {
 }
 __name(detectLineEndingFromContent, "detectLineEndingFromContent");
 
+// packages/core/src/utils/request-tokenizer/supportedImageFormats.ts
+init_esbuild_shims();
+var SUPPORTED_IMAGE_MIME_TYPES = [
+  "image/bmp",
+  "image/gif",
+  "image/jpeg",
+  "image/jpg",
+  // Alternative MIME type for JPEG
+  "image/png",
+  "image/tiff",
+  "image/webp",
+  "image/heic"
+];
+var PIPELINE_IMAGE_MIME_TYPES = [
+  "image/gif",
+  "image/jpeg",
+  "image/jpg",
+  "image/png",
+  "image/webp"
+];
+function isSupportedImageMimeType(mimeType) {
+  return SUPPORTED_IMAGE_MIME_TYPES.includes(
+    mimeType
+  );
+}
+__name(isSupportedImageMimeType, "isSupportedImageMimeType");
+function getSupportedImageFormatsString() {
+  return PIPELINE_IMAGE_MIME_TYPES.map(
+    (type) => type.replace("image/", "").toUpperCase()
+  ).join(", ");
+}
+__name(getSupportedImageFormatsString, "getSupportedImageFormatsString");
+function getUnsupportedImageFormatWarning() {
+  return `Only the following image formats are supported: ${getSupportedImageFormatsString()}. Other formats may not work as expected.`;
+}
+__name(getUnsupportedImageFormatWarning, "getUnsupportedImageFormatWarning");
+
 // packages/core/src/utils/fileUtils.ts
 var debugLogger2 = createDebugLogger("FILE_UTILS");
 var CANONICAL_IMAGE_MIME_TYPES = /* @__PURE__ */ new Set([
@@ -7914,6 +8209,18 @@ var CANONICAL_IMAGE_MIME_TYPES = /* @__PURE__ */ new Set([
   "image/png",
   "image/webp"
 ]);
+var CANONICAL_IMAGE_EXTENSIONS = new Set(
+  [...CANONICAL_IMAGE_MIME_TYPES].map(
+    (mimeType) => extensionForMimeType(mimeType)
+  )
+);
+var SNIFFABLE_IMAGE_MIME_TYPES = /* @__PURE__ */ new Set([
+  "image/gif",
+  "image/jpeg",
+  "image/png",
+  "image/webp"
+]);
+var IMAGE_SNIFF_BYTES = 8192;
 var PROVIDER_SAFE_IMAGE_MIME_TYPES = new Set(
   PIPELINE_IMAGE_MIME_TYPES
 );
@@ -8139,9 +8446,9 @@ function getSpecificMimeType(filePath) {
 }
 __name(getSpecificMimeType, "getSpecificMimeType");
 function isWithinRoot(pathToCheck, rootDirectory) {
-  const normalizedPathToCheck = path2.resolve(pathToCheck);
-  const normalizedRootDirectory = path2.resolve(rootDirectory);
-  const rootWithSeparator = normalizedRootDirectory === path2.sep || normalizedRootDirectory.endsWith(path2.sep) ? normalizedRootDirectory : normalizedRootDirectory + path2.sep;
+  const normalizedPathToCheck = path3.resolve(pathToCheck);
+  const normalizedRootDirectory = path3.resolve(rootDirectory);
+  const rootWithSeparator = normalizedRootDirectory === path3.sep || normalizedRootDirectory.endsWith(path3.sep) ? normalizedRootDirectory : normalizedRootDirectory + path3.sep;
   return normalizedPathToCheck === normalizedRootDirectory || normalizedPathToCheck.startsWith(rootWithSeparator);
 }
 __name(isWithinRoot, "isWithinRoot");
@@ -8352,8 +8659,45 @@ __name(isTextMime, "isTextMime");
 var MIME_LITE_MISSING_VIDEO_TYPES = /* @__PURE__ */ new Map([
   [".m4v", "video/x-m4v"]
 ]);
+async function classifyImageContent(filePath, mimeType) {
+  if (!SNIFFABLE_IMAGE_MIME_TYPES.has(mimeType)) return "image";
+  let handle;
+  try {
+    handle = await fs3.promises.open(
+      filePath,
+      (fs3.constants?.O_RDONLY ?? 0) | (fs3.constants?.O_NONBLOCK ?? 0)
+    );
+    if ((await handle.stat()).size > IMAGE_MAX_SOURCE_BYTES) return "image";
+    const sample = Buffer.alloc(IMAGE_SNIFF_BYTES);
+    const { bytesRead } = await handle.read(sample, 0, sample.length, 0);
+    const bytes = sample.subarray(0, bytesRead);
+    if (bytes.length === 0) return "image";
+    const sniffed = sniffFileKind(bytes, mimeType, "", `file://${filePath}`);
+    let result;
+    if (sniffed.magicMatched) {
+      result = sniffed.extension === extensionForMimeType(mimeType) || CANONICAL_IMAGE_EXTENSIONS.has(sniffed.extension) ? "image" : "binary";
+    } else {
+      result = bytes.length < 3 || !(detectBOM(bytes) || looksLikeText(bytes)) ? "binary" : "text";
+    }
+    if (result !== "image") {
+      debugLogger2.debug(
+        `classifyImageContent: ${filePath} -> ${result} (mime ${mimeType})`
+      );
+    }
+    return result;
+  } catch (error) {
+    debugLogger2.debug(
+      `Unable to sniff image content for ${filePath}; preserving extension classification`,
+      error instanceof Error ? error.message : String(error)
+    );
+    return "image";
+  } finally {
+    await handle?.close().catch(() => void 0);
+  }
+}
+__name(classifyImageContent, "classifyImageContent");
 async function detectFileType(filePath) {
-  const ext = path2.extname(filePath).toLowerCase();
+  const ext = path3.extname(filePath).toLowerCase();
   if ([".ts", ".mts", ".cts", ".tsx"].includes(ext)) {
     return "text";
   }
@@ -8366,7 +8710,7 @@ async function detectFileType(filePath) {
   const lookedUpMimeType = index_lite_default.getType(filePath) ?? MIME_LITE_MISSING_VIDEO_TYPES.get(ext) ?? null;
   if (lookedUpMimeType) {
     if (lookedUpMimeType.startsWith("image/")) {
-      return "image";
+      return classifyImageContent(filePath, lookedUpMimeType);
     }
     if (lookedUpMimeType.startsWith("audio/")) {
       return "audio";
@@ -8393,7 +8737,7 @@ async function detectFileType(filePath) {
     );
     return "text";
   }
-  if (KNOWN_TEXT_BASENAMES.has(path2.basename(filePath))) {
+  if (KNOWN_TEXT_BASENAMES.has(path3.basename(filePath))) {
     debugLogger2.debug(
       `detectFileType: ${filePath} \u2192 text (basename-override, mime ${lookedUpMimeType ?? "null"})`
     );
@@ -8438,7 +8782,7 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
     displayPath = filePath
   } = options;
   const rootDirectory = config.getTargetDir();
-  const relativePathForDisplay = (path2.isAbsolute(displayPath) ? path2.relative(rootDirectory, displayPath) : displayPath).replace(/\\/g, "/");
+  const relativePathForDisplay = (path3.isAbsolute(displayPath) ? path3.relative(rootDirectory, displayPath) : displayPath).replace(/\\/g, "/");
   try {
     signal?.throwIfAborted();
     let stats;
@@ -8465,16 +8809,17 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
     }
     if (!stats.isFile()) {
       return {
-        llmContent: `Cannot read file: ${path2.basename(filePath)} is not a regular file (e.g. device, socket, or pipe).`,
+        llmContent: `Cannot read file: ${path3.basename(filePath)} is not a regular file (e.g. device, socket, or pipe).`,
         returnDisplay: "Not a regular file.",
         error: `Not a regular file: ${displayPath}`,
         errorType: "read_content_failure" /* READ_CONTENT_FAILURE */
       };
     }
-    const fileType = options.textFileHandle ? "text" : await detectFileType(filePath);
-    const mediaMimeType = index_lite_default.getType(filePath) ?? MIME_LITE_MISSING_VIDEO_TYPES.get(path2.extname(filePath).toLowerCase()) ?? "application/octet-stream";
+    const mediaMimeType = index_lite_default.getType(filePath) ?? MIME_LITE_MISSING_VIDEO_TYPES.get(path3.extname(filePath).toLowerCase()) ?? "application/octet-stream";
+    const bridgePreservesImage = preserveUnsupportedImage && mediaMimeType.startsWith("image/") && SNIFFABLE_IMAGE_MIME_TYPES.has(mediaMimeType);
+    const fileType = options.textFileHandle ? "text" : options.fileType ?? (bridgePreservesImage ? "image" : await detectFileType(filePath));
     const shouldRenderImageOverview = fileType === "image" && CANONICAL_IMAGE_MIME_TYPES.has(mediaMimeType);
-    const displayName = path2.basename(displayPath);
+    const displayName = path3.basename(displayPath);
     const modalities = config.getContentGeneratorConfig?.()?.modalities ?? {};
     const willRenderPdfImages = fileType === "pdf" && !!modalities.image && largePdfBehavior !== "reference";
     const renderForBridge = fileType === "pdf" && !modalities.image && !modalities.pdf && (preserveUnsupportedImage || preparePdfForVisionBridge);
@@ -9105,6 +9450,9 @@ __name(fileExists, "fileExists");
 export {
   VISION_BRIDGE_MAX_IMAGES,
   VISION_BRIDGE_MAX_IMAGE_BASE64_BYTES,
+  TOKEN_ESTIMATE_UNITS_PER_TOKEN,
+  estimateTextTokens,
+  estimateTextTokenUnits,
   isUtf8CompatibleEncoding,
   loadIconvLite,
   LOCAL_CONTEXT_FILENAME,
@@ -9118,6 +9466,11 @@ export {
   PDF_MAX_PAGES_PER_READ,
   parsePDFPageRange,
   extractPDFText,
+  isBinaryContentType,
+  sniffFileKind,
+  looksLikeText,
+  persistBinaryContent,
+  formatByteSize,
   normalizeSource,
   parseNotebook,
   inferNotebookJsonFormat,
@@ -9138,6 +9491,8 @@ export {
   readTextCursorWindowFromHandle,
   ImageViewError,
   renderNormalizedImageCrop,
+  isSupportedImageMimeType,
+  getUnsupportedImageFormatWarning,
   decodeBufferWithEncodingInfoAsync,
   readFileWithLineAndLimit,
   getSpecificMimeType,
@@ -9152,6 +9507,11 @@ export {
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
 /**
  * @license
  * Copyright 2025 Qwen Team

package/chunks/{chunk-S3G6YFQC.js → chunk-WEGXPP5E.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-RKUWKYED.js";
 import {
   createDebugLogger
-} from "./chunk-A5F2YNO6.js";
+} from "./chunk-2NNTE2ED.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-RDQ7QB4Y.js → chunk-XJS54K4A.js}

@@ -2,10 +2,10 @@
 "use strict";
 import {
   isTeamAutoMemPath
-} from "./chunk-HIK2OF33.js";
+} from "./chunk-PVBT5QPD.js";
 import {
   createDebugLogger
-} from "./chunk-A5F2YNO6.js";
+} from "./chunk-2NNTE2ED.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-L4HVF7LM.js → chunk-XNXWEGKB.js}

@@ -12,19 +12,19 @@ import {
 } from "./chunk-MR3PXB6E.js";
 import {
   ideContextStore
-} from "./chunk-T6XLJRQY.js";
+} from "./chunk-XYX474JQ.js";
 import {
   require_proper_lockfile
 } from "./chunk-MLXTMF7H.js";
 import {
   atomicWriteFileSync
-} from "./chunk-HDKCKCYO.js";
+} from "./chunk-7QGEJI7M.js";
 import {
   FatalConfigError,
   Storage,
   createDebugLogger,
   getErrorMessage
-} from "./chunk-A5F2YNO6.js";
+} from "./chunk-2NNTE2ED.js";
 import {
   writeStderrLine
 } from "./chunk-KGJGEEVR.js";