@qwen-code/qwen-code 0.24.5-preview.0 → 0.24.5

package/chunks/{chunk-NNN2PKPV.js → chunk-PYYPSK6Q.js}

@@ -1,5 +1,13 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  IMAGE_MAX_SOURCE_BYTES,
+  ImageViewError,
+  extensionForMimeType,
+  looksLikeText,
+  renderImageOverview,
+  sniffFileKind
+} from "./chunk-CLNDQINM.js";
 import {
   detectEncodingFromBuffer
 } from "./chunk-GMTJ3YQW.js";
@@ -461,227 +469,6 @@ 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";
@@ -949,245 +736,11 @@ ${cellTexts.join("\n\n")}`,
 }
 __name(readNotebookWithMetadata, "readNotebookWithMetadata");
 
-// packages/core/src/utils/image-view.ts
-init_esbuild_shims();
-import fs2 from "node:fs/promises";
-var IMAGE_VIEW_MAX_EDGE = 1568;
-var IMAGE_VIEW_MAX_PATCHES = 1568;
-var IMAGE_PATCH_SIZE = 28;
-var IMAGE_MAX_UPSCALE = 8;
-var IMAGE_JPEG_QUALITY = 92;
-var IMAGE_MAX_SOURCE_BYTES = 100 * 1024 * 1024;
-var IMAGE_MAX_OUTPUT_BYTES = 9 * 1024 * 1024;
-var SUPPORTED_IMAGE_FORMATS = /* @__PURE__ */ new Set(["jpeg", "png", "webp"]);
-var ImageViewError = class extends Error {
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-  }
-  static {
-    __name(this, "ImageViewError");
-  }
-};
-function orientedSize(metadata) {
-  const autoOrient = metadata.autoOrient;
-  if (autoOrient) {
-    return { width: autoOrient.width, height: autoOrient.height };
-  }
-  const width = metadata.width ?? 0;
-  const height = metadata.height ?? 0;
-  const orientation = metadata.orientation ?? 0;
-  return orientation >= 5 && orientation <= 8 ? { width: height, height: width } : { width, height };
-}
-__name(orientedSize, "orientedSize");
-function fitsVisualBudget({ width, height }) {
-  return width <= IMAGE_VIEW_MAX_EDGE && height <= IMAGE_VIEW_MAX_EDGE && Math.ceil(width / IMAGE_PATCH_SIZE) * Math.ceil(height / IMAGE_PATCH_SIZE) <= IMAGE_VIEW_MAX_PATCHES;
-}
-__name(fitsVisualBudget, "fitsVisualBudget");
-function boundedSize(width, height, maxUpscale) {
-  const widthIsLongEdge = width >= height;
-  const maxLongEdge = Math.min(
-    IMAGE_VIEW_MAX_EDGE,
-    Math.max(width, height) * maxUpscale
-  );
-  let low = 1;
-  let high = maxLongEdge;
-  let best = { width: 1, height: 1 };
-  while (low <= high) {
-    const longEdge = Math.floor((low + high) / 2);
-    const candidate = widthIsLongEdge ? {
-      width: longEdge,
-      height: Math.max(1, Math.round(height / width * longEdge))
-    } : {
-      width: Math.max(1, Math.round(width / height * longEdge)),
-      height: longEdge
-    };
-    if (fitsVisualBudget(candidate)) {
-      best = candidate;
-      low = longEdge + 1;
-    } else {
-      high = longEdge - 1;
-    }
-  }
-  return best;
-}
-__name(boundedSize, "boundedSize");
-async function prepareImage(filePath, signal) {
-  signal.throwIfAborted();
-  let sharp;
-  try {
-    sharp = (await import("sharp")).default;
-  } catch {
-    throw new ImageViewError(
-      "renderer_unavailable",
-      'Image rendering is unavailable because the "sharp" image module could not be loaded.'
-    );
-  }
-  let stats;
-  try {
-    stats = await fs2.stat(filePath);
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      throw new ImageViewError(
-        "file_not_found",
-        `Image file not found: ${filePath}`
-      );
-    }
-    throw error;
-  }
-  if (stats.isDirectory()) {
-    throw new ImageViewError(
-      "target_is_directory",
-      `Image path is a directory: ${filePath}`
-    );
-  }
-  if (!stats.isFile()) {
-    throw new ImageViewError(
-      "target_not_regular_file",
-      `Image path is not a regular file: ${filePath}`
-    );
-  }
-  if (stats.size > IMAGE_MAX_SOURCE_BYTES) {
-    throw new ImageViewError(
-      "source_too_large",
-      `Image file exceeds the 100 MB source limit: ${filePath}`
-    );
-  }
-  const bytes = await fs2.readFile(filePath, { signal });
-  if (bytes.length > IMAGE_MAX_SOURCE_BYTES) {
-    throw new ImageViewError(
-      "source_too_large",
-      `Image file exceeds the 100 MB source limit: ${filePath}`
-    );
-  }
-  let metadata;
-  try {
-    metadata = await sharp(bytes, {
-      failOn: "error",
-      limitInputPixels: true
-    }).metadata();
-  } catch {
-    signal.throwIfAborted();
-    throw new ImageViewError(
-      "decode_failed",
-      `Failed to decode image (file may be corrupt or not a static PNG, JPEG, or WebP): ${filePath}`
-    );
-  }
-  signal.throwIfAborted();
-  if (!SUPPORTED_IMAGE_FORMATS.has(metadata.format)) {
-    throw new ImageViewError(
-      "unsupported_image",
-      `Unsupported image. Expected a static PNG, JPEG, or WebP file: ${filePath}`
-    );
-  }
-  if ((metadata.pages ?? 1) > 1) {
-    throw new ImageViewError(
-      "animated_image",
-      `Only static images are supported: ${filePath}`
-    );
-  }
-  return { bytes, metadata, sharp };
-}
-__name(prepareImage, "prepareImage");
-async function renderImageView(filePath, prepared, selection, outputSize, signal) {
-  const { bytes, metadata, sharp } = prepared;
-  const sourceSize = orientedSize(metadata);
-  let output;
-  try {
-    output = await sharp(bytes, {
-      failOn: "error",
-      limitInputPixels: true
-    }).rotate().extract(selection).resize(outputSize.width, outputSize.height, {
-      fit: "fill",
-      kernel: sharp.kernel.lanczos3
-    }).flatten({ background: "#ffffff" }).jpeg({
-      quality: IMAGE_JPEG_QUALITY,
-      chromaSubsampling: "4:4:4"
-    }).toBuffer();
-  } catch {
-    signal.throwIfAborted();
-    throw new ImageViewError(
-      "decode_failed",
-      `Failed to render image overview: ${filePath}`
-    );
-  }
-  signal.throwIfAborted();
-  if (output.length > IMAGE_MAX_OUTPUT_BYTES) {
-    throw new ImageViewError(
-      "output_too_large",
-      `Rendered image exceeds the 9 MB output limit: ${filePath}`
-    );
-  }
-  return {
-    bytes: output,
-    mimeType: "image/jpeg",
-    sourceWidth: sourceSize.width,
-    sourceHeight: sourceSize.height,
-    selectedWidth: selection.width,
-    selectedHeight: selection.height,
-    outputWidth: outputSize.width,
-    outputHeight: outputSize.height
-  };
-}
-__name(renderImageView, "renderImageView");
-async function renderImageOverview(filePath, signal) {
-  const prepared = await prepareImage(filePath, signal);
-  const { width: sourceWidth, height: sourceHeight } = orientedSize(
-    prepared.metadata
-  );
-  const outputSize = boundedSize(sourceWidth, sourceHeight, 1);
-  return renderImageView(
-    filePath,
-    prepared,
-    { left: 0, top: 0, width: sourceWidth, height: sourceHeight },
-    outputSize,
-    signal
-  );
-}
-__name(renderImageOverview, "renderImageOverview");
-async function renderNormalizedImageCrop(filePath, region, signal) {
-  const prepared = await prepareImage(filePath, signal);
-  const { width: sourceWidth, height: sourceHeight } = orientedSize(
-    prepared.metadata
-  );
-  const left = Math.min(
-    sourceWidth - 1,
-    Math.max(0, Math.floor(region.x1 / 1e3 * sourceWidth))
-  );
-  const top = Math.min(
-    sourceHeight - 1,
-    Math.max(0, Math.floor(region.y1 / 1e3 * sourceHeight))
-  );
-  const right = Math.min(
-    sourceWidth,
-    Math.max(left + 1, Math.ceil(region.x2 / 1e3 * sourceWidth))
-  );
-  const bottom = Math.min(
-    sourceHeight,
-    Math.max(top + 1, Math.ceil(region.y2 / 1e3 * sourceHeight))
-  );
-  const selectedWidth = right - left;
-  const selectedHeight = bottom - top;
-  const outputSize = boundedSize(
-    selectedWidth,
-    selectedHeight,
-    IMAGE_MAX_UPSCALE
-  );
-  return renderImageView(
-    filePath,
-    prepared,
-    { left, top, width: selectedWidth, height: selectedHeight },
-    outputSize,
-    signal
-  );
-}
-__name(renderNormalizedImageCrop, "renderNormalizedImageCrop");
-
 // packages/core/src/utils/fileUtils.ts
 init_esbuild_shims();
-import fs3 from "node:fs";
+import fs2 from "node:fs";
 import fsPromises from "node:fs/promises";
-import path3 from "node:path";
+import path2 from "node:path";
 
 // packages/core/node_modules/mime/dist/src/index_lite.js
 init_esbuild_shims();
@@ -1611,12 +1164,12 @@ var Mime = class {
     }
     return this;
   }
-  getType(path4) {
-    if (typeof path4 !== "string")
+  getType(path3) {
+    if (typeof path3 !== "string")
       return null;
-    const last = path4.replace(/^.*[/\\]/s, "").toLowerCase();
+    const last = path3.replace(/^.*[/\\]/s, "").toLowerCase();
     const ext = last.replace(/^.*\./s, "").toLowerCase();
-    const hasPath = last.length < path4.length;
+    const hasPath = last.length < path3.length;
     const hasDot = ext.length < last.length - 1;
     if (!hasDot && hasPath)
       return null;
@@ -1686,7 +1239,7 @@ __name(loadIconvLite, "loadIconvLite");
 
 // packages/core/src/utils/ignorePatterns.ts
 init_esbuild_shims();
-import path2 from "node:path";
+import path from "node:path";
 var COMMON_IGNORE_PATTERNS = [
   "**/node_modules/**",
   "**/.git/**",
@@ -1825,7 +1378,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 = path2.extname(`dummy${extPart}`);
+        const extracted = path.extname(`dummy${extPart}`);
         const result = extracted || extPart;
         return result && result !== "." && !result.substring(1).includes(".") ? [result] : [];
       }
@@ -2535,7 +2088,7 @@ function bomEncodingToName(bomEncoding) {
 }
 __name(bomEncodingToName, "bomEncodingToName");
 async function readFileWithEncodingInfo(filePath, signal) {
-  const full = await fs3.promises.readFile(
+  const full = await fs2.promises.readFile(
     filePath,
     signal === void 0 ? void 0 : { signal }
   );
@@ -2554,7 +2107,7 @@ async function countFileLines(filePath) {
 __name(countFileLines, "countFileLines");
 async function readFileWithLineAndLimit(params) {
   const { path: filePath, limit, line, maxOutputBytes, signal } = params;
-  const stats = params.stats ?? await fs3.promises.stat(filePath);
+  const stats = params.stats ?? await fs2.promises.stat(filePath);
   if (line !== void 0 && line > 0 || Number.isFinite(limit) || maxOutputBytes !== void 0) {
     return readTextRange({
       path: filePath,
@@ -2592,7 +2145,7 @@ __name(readFileWithLineAndLimit, "readFileWithLineAndLimit");
 async function detectFileEncoding(source) {
   let opened = null;
   try {
-    const fh = typeof source === "string" ? opened = await fs3.promises.open(source, "r") : source;
+    const fh = typeof source === "string" ? opened = await fs2.promises.open(source, "r") : source;
     const stats = await fh.stat();
     if (stats.size === 0) return "utf-8";
     const sampleSize = Math.min(8192, stats.size);
@@ -2626,16 +2179,16 @@ function getSpecificMimeType(filePath) {
 }
 __name(getSpecificMimeType, "getSpecificMimeType");
 function isWithinRoot(pathToCheck, rootDirectory) {
-  const normalizedPathToCheck = path3.resolve(pathToCheck);
-  const normalizedRootDirectory = path3.resolve(rootDirectory);
-  const rootWithSeparator = normalizedRootDirectory === path3.sep || normalizedRootDirectory.endsWith(path3.sep) ? normalizedRootDirectory : normalizedRootDirectory + path3.sep;
+  const normalizedPathToCheck = path2.resolve(pathToCheck);
+  const normalizedRootDirectory = path2.resolve(rootDirectory);
+  const rootWithSeparator = normalizedRootDirectory === path2.sep || normalizedRootDirectory.endsWith(path2.sep) ? normalizedRootDirectory : normalizedRootDirectory + path2.sep;
   return normalizedPathToCheck === normalizedRootDirectory || normalizedPathToCheck.startsWith(rootWithSeparator);
 }
 __name(isWithinRoot, "isWithinRoot");
 async function isBinaryFile(filePath) {
   let fh = null;
   try {
-    fh = await fs3.promises.open(filePath, "r");
+    fh = await fs2.promises.open(filePath, "r");
     const stats = await fh.stat();
     const fileSize = stats.size;
     if (fileSize === 0) return false;
@@ -2847,9 +2400,9 @@ async function classifyImageContent(filePath, mimeType) {
   if (!SNIFFABLE_IMAGE_MIME_TYPES.has(mimeType)) return "image";
   let handle;
   try {
-    handle = await fs3.promises.open(
+    handle = await fs2.promises.open(
       filePath,
-      (fs3.constants?.O_RDONLY ?? 0) | (fs3.constants?.O_NONBLOCK ?? 0)
+      (fs2.constants?.O_RDONLY ?? 0) | (fs2.constants?.O_NONBLOCK ?? 0)
     );
     if ((await handle.stat()).size > IMAGE_MAX_SOURCE_BYTES) return "image";
     const sample = Buffer.alloc(IMAGE_SNIFF_BYTES);
@@ -2881,7 +2434,7 @@ async function classifyImageContent(filePath, mimeType) {
 }
 __name(classifyImageContent, "classifyImageContent");
 async function detectFileType(filePath) {
-  const ext = path3.extname(filePath).toLowerCase();
+  const ext = path2.extname(filePath).toLowerCase();
   if ([".ts", ".mts", ".cts", ".tsx"].includes(ext)) {
     return "text";
   }
@@ -2921,7 +2474,7 @@ async function detectFileType(filePath) {
     );
     return "text";
   }
-  if (KNOWN_TEXT_BASENAMES.has(path3.basename(filePath))) {
+  if (KNOWN_TEXT_BASENAMES.has(path2.basename(filePath))) {
     debugLogger.debug(
       `detectFileType: ${filePath} \u2192 text (basename-override, mime ${lookedUpMimeType ?? "null"})`
     );
@@ -2966,12 +2519,12 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
     displayPath = filePath
   } = options;
   const rootDirectory = config.getTargetDir();
-  const relativePathForDisplay = (path3.isAbsolute(displayPath) ? path3.relative(rootDirectory, displayPath) : displayPath).replace(/\\/g, "/");
+  const relativePathForDisplay = (path2.isAbsolute(displayPath) ? path2.relative(rootDirectory, displayPath) : displayPath).replace(/\\/g, "/");
   try {
     signal?.throwIfAborted();
     let stats;
     try {
-      stats = options.textFileStats ?? await fs3.promises.stat(filePath);
+      stats = options.textFileStats ?? await fs2.promises.stat(filePath);
     } catch (error) {
       if (isNodeError(error) && error.code === "ENOENT") {
         return {
@@ -2993,13 +2546,13 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
     }
     if (!stats.isFile()) {
       return {
-        llmContent: `Cannot read file: ${path3.basename(filePath)} is not a regular file (e.g. device, socket, or pipe).`,
+        llmContent: `Cannot read file: ${path2.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 mediaMimeType = index_lite_default.getType(filePath) ?? MIME_LITE_MISSING_MEDIA_TYPES.get(path3.extname(filePath).toLowerCase()) ?? "application/octet-stream";
+    const mediaMimeType = index_lite_default.getType(filePath) ?? MIME_LITE_MISSING_MEDIA_TYPES.get(path2.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));
     if (fileType === "pdf" && config.getShellExecutionSandbox?.()) {
@@ -3012,7 +2565,7 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
       };
     }
     const shouldRenderImageOverview = fileType === "image" && CANONICAL_IMAGE_MIME_TYPES.has(mediaMimeType);
-    const displayName = path3.basename(displayPath);
+    const displayName = path2.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);
@@ -3334,7 +2887,7 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
             returnDisplay: `Omitted unsupported image format: ${relativePathForDisplay} (${mediaMimeType})`
           };
         }
-        const contentBuffer = await fs3.promises.readFile(filePath);
+        const contentBuffer = await fs2.promises.readFile(filePath);
         if (mediaMimeType === "image/gif") {
           const sharpModule = await import("sharp").catch(() => void 0);
           if (sharpModule) {
@@ -3387,7 +2940,7 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
             signal
           });
         }
-        const contentBuffer = await fs3.promises.readFile(filePath);
+        const contentBuffer = await fs2.promises.readFile(filePath);
         const base64Data = contentBuffer.toString("base64");
         const base64SizeInMB = base64Data.length / (1024 * 1024);
         if (base64SizeInMB > 9.9) {
@@ -3411,7 +2964,7 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
       }
       case "pdf": {
         if (!pageRange && modalities.pdf) {
-          const contentBuffer = await fs3.promises.readFile(filePath);
+          const contentBuffer = await fs2.promises.readFile(filePath);
           const base64Data = contentBuffer.toString("base64");
           const base64SizeInMB = base64Data.length / (1024 * 1024);
           if (base64SizeInMB > 9.9) {
@@ -3677,7 +3230,7 @@ function normalizeRangeReadByteLimit(maxOutputBytes) {
 __name(normalizeRangeReadByteLimit, "normalizeRangeReadByteLimit");
 async function fileExists(filePath) {
   try {
-    await fsPromises.access(filePath, fs3.constants.F_OK);
+    await fsPromises.access(filePath, fs2.constants.F_OK);
     return true;
   } catch (_) {
     return false;
@@ -3703,11 +3256,6 @@ export {
   extractPDFText,
   VISION_BRIDGE_MAX_IMAGES,
   VISION_BRIDGE_MAX_IMAGE_BASE64_BYTES,
-  isBinaryContentType,
-  sniffFileKind,
-  looksLikeText,
-  persistBinaryContent,
-  formatByteSize,
   normalizeSource,
   parseNotebook,
   inferNotebookJsonFormat,
@@ -3726,8 +3274,6 @@ export {
   TextScanBudgetExceededError,
   readTextRangeFromHandle,
   readTextCursorWindowFromHandle,
-  ImageViewError,
-  renderNormalizedImageCrop,
   isSupportedImageMimeType,
   getUnsupportedImageFormatWarning,
   decodeBufferWithEncodingInfoAsync,
@@ -3754,11 +3300,6 @@ export {
  * Copyright 2025 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */
-/**
- * @license
- * Copyright 2026 Qwen
- * SPDX-License-Identifier: Apache-2.0
- */
 /**
  * @license
  * Copyright 2026 Qwen Team