@qwen-code/qwen-code 0.23.5-preview.0 → 0.24.0

package/chunks/{chunk-IKBEIDOH.js → chunk-SOZJODVX.js}

@@ -2,34 +2,34 @@
 "use strict";
 import {
   appEvents
-} from "./chunk-CXY6BICQ.js";
+} from "./chunk-HWKWZSZY.js";
 import {
   CUSTOM_SANDBOX_IMAGE_ENV_VAR,
   HOST_UPDATE_RELAUNCH_ENV_VAR,
   SKIP_UPDATE_CHECK_ENV_VAR,
   requestUpdateOnExit
-} from "./chunk-B5TJK7B3.js";
+} from "./chunk-NZRX5WYI.js";
 import {
   loadUndici
 } from "./chunk-TXASDT2M.js";
 import {
   IdeClient
-} from "./chunk-KAYC5FBN.js";
+} from "./chunk-SNPYTKXI.js";
 import {
   getAllProviderBaseUrls
-} from "./chunk-KEM7MWS7.js";
+} from "./chunk-366JNNY7.js";
 import {
   detectRuntime,
   getOrCreateSharedDispatcher,
   preloadRuntimeFetchModule,
   redactProxyCredentials
-} from "./chunk-7O5PYQ3M.js";
+} from "./chunk-SBP43AO6.js";
 import {
   initializeTelemetry
-} from "./chunk-6USYH3EU.js";
+} from "./chunk-B3XJFEEH.js";
 import {
   createDebugLogger
-} from "./chunk-ZAFYHRVY.js";
+} from "./chunk-ZYDMQCQP.js";
 import {
   recordStartupEvent
 } from "./chunk-QILD6R27.js";
@@ -233,11 +233,11 @@ function startPostRenderPrefetches(config, settings, options = {}) {
         { updateEventEmitter },
         { t }
       ] = await Promise.all([
-        import("./updateCheck-PKSSORPO.js"),
-        import("./handleAutoUpdate-FZP45KOR.js"),
-        import("./installationInfo-2IJV5QKC.js"),
+        import("./updateCheck-FXXOM4YS.js"),
+        import("./handleAutoUpdate-5OQL4YBU.js"),
+        import("./installationInfo-HYOWC3BN.js"),
         import("./updateEventEmitter-5MKC7BLQ.js"),
-        import("./i18n-OTB62AKW.js")
+        import("./i18n-TV5G7SXO.js")
       ]);
       const updateCheckSkippedMessage = /* @__PURE__ */ __name((error) => t("Update check skipped ({{reason}}) \u2014 run /update to retry.", {
         reason: describeUpdateCheckFailure(error)
@@ -310,7 +310,7 @@ ${t(
         state: "connecting"
       });
       try {
-        const { connectIdeForStartup } = await import("./initializer-4JXZEC4B.js");
+        const { connectIdeForStartup } = await import("./initializer-R2EI4UJ6.js");
         await withTimeout(
           connectIdeForStartup(config),
           "ide_connect",
@@ -334,7 +334,7 @@ ${t(
   }
   if (config.isInteractive()) {
     runDeferredTask("background_housekeeping", async () => {
-      const { startBackgroundHousekeeping } = await import("./scheduler-GCZYLZ2P.js");
+      const { startBackgroundHousekeeping } = await import("./scheduler-NHAWKARI.js");
       startBackgroundHousekeeping(config, settings);
     });
   }

package/chunks/{chunk-Y4NNIGYO.js → chunk-SSFOFDNL.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   t
-} from "./chunk-GSAOVDTH.js";
+} from "./chunk-POMFSBEC.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-WNQIJTOP.js → chunk-SSGVTJ2W.js}

@@ -2,11 +2,11 @@
 "use strict";
 import {
   t
-} from "./chunk-GSAOVDTH.js";
+} from "./chunk-POMFSBEC.js";
 import {
   SessionReferenceService,
   readManyFiles
-} from "./chunk-347O2YZJ.js";
+} from "./chunk-CNG7ILRW.js";
 import {
   emptyMcpResourceText,
   formatMcpResourceContents,
@@ -14,22 +14,24 @@ import {
 } from "./chunk-ZPJWUGCS.js";
 import {
   SessionService
-} from "./chunk-KAYC5FBN.js";
+} from "./chunk-SNPYTKXI.js";
 import {
   qualifySkillName,
   stripTerminalControlSequences
-} from "./chunk-P42KMMU6.js";
+} from "./chunk-KWTLCPYY.js";
 import {
   shouldRunVisionBridge
-} from "./chunk-CDDP4ONL.js";
+} from "./chunk-G3PBYAGM.js";
 import {
   Storage,
-  getErrorMessage,
-  isNodeError,
   isSubpath,
   unescapePath,
   unescapeShellSpecials
-} from "./chunk-ZAFYHRVY.js";
+} from "./chunk-ZYDMQCQP.js";
+import {
+  getErrorMessage,
+  isNodeError
+} from "./chunk-S34QJ6IR.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -325,6 +327,8 @@ function parseAllAtCommands(query) {
         content: query.substring(currentIndex, atIndex)
       });
     }
+    const isUrlRef = /^https?:\/\//i.test(query.slice(atIndex + 1));
+    const NON_URL_CHAR = /[^A-Za-z0-9\-._~:/?#[\]@!$&'()*+,;=%]/;
     let pathEndIndex = atIndex + 1;
     let inEscape = false;
     while (pathEndIndex < query.length) {
@@ -333,6 +337,8 @@ function parseAllAtCommands(query) {
         inEscape = false;
       } else if (char === "\\") {
         inEscape = true;
+      } else if (isUrlRef) {
+        if (NON_URL_CHAR.test(char)) break;
       } else if (/[,\s;!?()[\]{}]/.test(char)) {
         break;
       } else if (char === ".") {
@@ -343,7 +349,12 @@ function parseAllAtCommands(query) {
       }
       pathEndIndex++;
     }
-    const rawAtPath = query.substring(atIndex, pathEndIndex);
+    let rawAtPath = query.substring(atIndex, pathEndIndex);
+    if (isUrlRef) {
+      const trimmed = rawAtPath.replace(/[.,;:!?]+$/, "");
+      pathEndIndex = atIndex + trimmed.length;
+      rawAtPath = trimmed;
+    }
     const atPath = unescapePath(rawAtPath);
     parts.push({ type: "atPath", content: atPath });
     currentIndex = pathEndIndex;
@@ -410,6 +421,8 @@ async function resolveAtCommandQuery({
   const activeExtensions = config.getActiveExtensions?.() ?? [];
   const extensionMentions = [];
   const sessionMentions = [];
+  const urlMediaRefs = [];
+  const rememberedMediaRefs = [];
   for (const atPathPart of atPathCommandParts) {
     const originalAtPath = atPathPart.content;
     if (originalAtPath === "@") {
@@ -419,6 +432,16 @@ async function resolveAtCommandQuery({
       continue;
     }
     const pathName = originalAtPath.substring(1);
+    if (/^https?:\/\//i.test(pathName) && config.isOmniEnabled?.()) {
+      const omni = await import("./omni-A5XLPNSH.js");
+      if (omni.isOmniDeliveryActive(config) && omni.parseHttpUrlRef(pathName)) {
+        if (!urlMediaRefs.some((r) => r.url === pathName)) {
+          urlMediaRefs.push({ originalAtPath, url: pathName });
+        }
+        atPathToResolvedSpecMap.set(originalAtPath, pathName);
+        continue;
+      }
+    }
     const extRef = parseExtensionRef(pathName);
     if (extRef) {
       const extension = matchExtensionByRef(extRef.name, activeExtensions);
@@ -544,9 +567,33 @@ async function resolveAtCommandQuery({
       }
     }
     if (!resolvedSuccessfully && sawNotFound) {
-      onDebugMessage(
-        `Path ${pathName} not found. Path ${pathName} will be skipped.`
-      );
+      let reanchored = false;
+      if (config.isOmniEnabled?.()) {
+        const { reanchorRememberedMedia } = await import("./omni-A5XLPNSH.js");
+        for (const dir of config.getWorkspaceContext().getDirectories()) {
+          const anchor = await reanchorRememberedMedia(
+            config,
+            path.resolve(dir, pathName)
+          );
+          if (!anchor) continue;
+          rememberedMediaRefs.push({
+            originalAtPath,
+            pathName,
+            annotation: anchor.annotation
+          });
+          atPathToResolvedSpecMap.set(originalAtPath, pathName);
+          onDebugMessage(
+            `Path ${pathName} is gone but remembered; re-anchored as ${anchor.resourceId} (bytes unavailable).`
+          );
+          reanchored = true;
+          break;
+        }
+      }
+      if (!reanchored) {
+        onDebugMessage(
+          `Path ${pathName} not found. Path ${pathName} will be skipped.`
+        );
+      }
     }
     if (!resolvedSuccessfully && deferredIgnoreReason) {
       ignoredByReason[deferredIgnoreReason].push(pathName);
@@ -600,6 +647,169 @@ ${messages.join("\n")}`;
       (ref) => config.getToolRegistry().readMcpResource(ref.serverName, ref.uri, { signal })
     )
   );
+  const urlMediaParts = [];
+  const urlMediaDisplays = [];
+  const urlMediaLabels = [];
+  if (urlMediaRefs.length > 0) {
+    const core = await import("./omni-A5XLPNSH.js");
+    for (let i = 0; i < urlMediaRefs.length; i++) {
+      const ref = urlMediaRefs[i];
+      const callId = `client-url-media-${userMessageTimestamp}-${i}`;
+      const hostLabel = (() => {
+        try {
+          return new URL(ref.url).hostname;
+        } catch {
+          return "invalid-url";
+        }
+      })();
+      let tempPartPath;
+      try {
+        const store = new core.OmniObjectStore(config.storage.getQwenDir());
+        const downloadsDir = path.join(store.getOmniRootDir(), "downloads");
+        const downloaded = await core.downloadMediaUrl({
+          url: ref.url,
+          downloadsDir,
+          maxBytes: core.effectiveMaxDownloadFileBytes(config),
+          signal
+        });
+        tempPartPath = downloaded.partPath;
+        const urlBase = path.basename(new URL(ref.url).pathname) || hostLabel;
+        const modalities = config.getContentGeneratorConfig?.()?.modalities ?? {};
+        const sniffedModality = await core.sniffFileModality(
+          downloaded.partPath
+        );
+        if (sniffedModality && !modalities[sniffedModality]) {
+          urlMediaDisplays.push({
+            callId,
+            name: "Fetch Media URL",
+            description: `Download ${ref.url}`,
+            status: "Error" /* Error */,
+            resultDisplay: `Skipped ${urlBase}: the active model does not accept ${sniffedModality} input.`,
+            confirmationDetails: void 0
+          });
+          continue;
+        }
+        const delivery = await core.processMediaForOmniDelivery(
+          downloaded.partPath,
+          config,
+          // displayName: guard/error messages must name the URL's file, not
+          // the opaque staging path the download landed under. sourceUrl:
+          // the staging path is deleted in the finally below, so memory
+          // must anchor this media's identity to the object store and
+          // record the URL as its source — a handle bound to the staging
+          // path would resolve to ENOENT for the rest of the session.
+          { signal, displayName: urlBase, sourceUrl: ref.url }
+        );
+        const transcriptParts = core.buildTranscriptParts(
+          urlBase,
+          delivery.transcripts
+        );
+        const additionalParts = core.buildAdditionalMediaParts(
+          urlBase,
+          delivery.additionalMedia
+        );
+        const handleParts = delivery.resourceId ? [
+          {
+            text: core.formatResourceHandleText(
+              urlBase,
+              delivery.resourceId
+            )
+          }
+        ] : [];
+        if (delivery.omission) {
+          urlMediaParts.push(...handleParts);
+          urlMediaParts.push({
+            text: core.formatOmissionText(urlBase, delivery.omission.reason)
+          });
+          urlMediaParts.push(...additionalParts);
+          urlMediaParts.push(...transcriptParts);
+          urlMediaLabels.push(ref.url);
+          urlMediaDisplays.push({
+            callId,
+            name: "Fetch Media URL",
+            description: `Downloaded ${ref.url}`,
+            status: "Success" /* Success */,
+            resultDisplay: `Media omitted by the omni transport guard: ${urlBase}`,
+            confirmationDetails: void 0
+          });
+          continue;
+        }
+        if (!delivery.fileUri && transcriptParts.length > 0) {
+          urlMediaParts.push(...handleParts);
+          if (delivery.disclosure) {
+            urlMediaParts.push({
+              text: core.formatDisclosureText(urlBase, delivery.disclosure)
+            });
+          }
+          urlMediaParts.push(...additionalParts);
+          urlMediaParts.push(...transcriptParts);
+          urlMediaLabels.push(ref.url);
+          urlMediaDisplays.push({
+            callId,
+            name: "Fetch Media URL",
+            description: `Downloaded ${ref.url}`,
+            status: "Success" /* Success */,
+            resultDisplay: `Localized ${urlBase} and delivered as transcript (omni policy).`,
+            confirmationDetails: void 0
+          });
+          continue;
+        }
+        urlMediaParts.push(...handleParts);
+        if (delivery.disclosure) {
+          urlMediaParts.push({
+            text: core.formatDisclosureText(urlBase, delivery.disclosure)
+          });
+        }
+        urlMediaParts.push({
+          fileData: {
+            fileUri: delivery.fileUri,
+            mimeType: delivery.mimeType,
+            displayName: urlBase
+          }
+        });
+        urlMediaParts.push(...additionalParts);
+        urlMediaParts.push(...transcriptParts);
+        urlMediaLabels.push(ref.url);
+        urlMediaDisplays.push({
+          callId,
+          name: "Fetch Media URL",
+          description: `Downloaded ${ref.url}`,
+          status: "Success" /* Success */,
+          resultDisplay: `Localized ${urlBase} (${delivery.recognized.modality}, ${(delivery.recognized.sizeBytes / 1024 / 1024).toFixed(1)}MB) and delivered via omni upload${delivery.degraded ? " (degraded by media policy)" : ""}.`,
+          confirmationDetails: void 0
+        });
+      } catch (error) {
+        if (signal.aborted) {
+          if (tempPartPath) {
+            await fs2.rm(tempPartPath, { force: true }).catch(() => {
+            });
+          }
+          return {
+            processedQuery: null,
+            shouldProceed: false,
+            toolDisplays: [...urlMediaDisplays],
+            filesRead: urlMediaLabels
+            // No chat-recording entry for a user-cancelled resolution.
+          };
+        }
+        const reason = getErrorMessage(error);
+        onDebugMessage(`Failed to localize media URL ${ref.url}: ${reason}`);
+        urlMediaDisplays.push({
+          callId,
+          name: "Fetch Media URL",
+          description: `Download ${ref.url}`,
+          status: "Error" /* Error */,
+          resultDisplay: `Failed to fetch media from ${hostLabel}: ${reason}`,
+          confirmationDetails: void 0
+        });
+      } finally {
+        if (tempPartPath) {
+          await fs2.rm(tempPartPath, { force: true }).catch(() => {
+          });
+        }
+      }
+    }
+  }
   const resourceParts = [];
   const resourceDisplays = [];
   const resourceLabels = [];
@@ -638,7 +848,10 @@ ${messages.join("\n")}`;
       confirmationDetails: void 0
     });
   }
-  if (pathSpecsToRead.length === 0 && mcpResourceRefs.length === 0 && mcpServerMentions.length === 0 && extensionMentions.length === 0 && sessionMentions.length === 0) {
+  if (pathSpecsToRead.length === 0 && mcpResourceRefs.length === 0 && mcpServerMentions.length === 0 && extensionMentions.length === 0 && sessionMentions.length === 0 && // URL media refs count as content too: without this, a URL-only prompt
+  // would run the whole download→upload pipeline and then discard the
+  // delivered parts (and their display cards) via this early return.
+  urlMediaRefs.length === 0) {
     onDebugMessage("No valid file paths found in @ commands to read.");
     if (initialQueryText === "@" && query.trim() === "@") {
       return { processedQuery: [{ text: query }], shouldProceed: true };
@@ -917,7 +1130,8 @@ ${messages.join("\n")}`;
       const labelsOnError = [
         ...scopedMentionLabels,
         ...contentLabelsForDisplay,
-        ...resourceLabels
+        ...resourceLabels,
+        ...urlMediaLabels
       ];
       return {
         processedQuery: null,
@@ -925,6 +1139,7 @@ ${messages.join("\n")}`;
         toolDisplays: [
           ...scopedMentionDisplays,
           ...resourceDisplays,
+          ...urlMediaDisplays,
           errorToolCallDisplay
         ],
         filesRead: labelsOnError,
@@ -936,16 +1151,26 @@ ${messages.join("\n")}`;
       };
     }
   }
+  const rememberedMediaParts = rememberedMediaRefs.flatMap((ref) => [
+    { text: ref.annotation },
+    {
+      text: `\u3010\u5A92\u4F53\u7F3A\u5931\u3011${ref.pathName}\uFF1A\u6587\u4EF6\u5DF2\u4E0D\u5728\u78C1\u76D8\u4E0A\uFF0C\u65E0\u6CD5\u6295\u9012\u753B\u9762/\u97F3\u9891\u3002\u5176\u5904\u7406\u8BB0\u5FC6\u4ECD\u53EF\u7528\u2014\u2014\u7528\u4E0A\u9762\u7684\u53E5\u67C4\u8C03\u7528 omni_recall_media_memory \u53D6\u56DE\u3002`
+    }
+  ]);
   const processedQueryParts = [
     { text: initialQueryText },
     ...scopedMentionParts,
     ...fileParts,
-    ...resourceParts
+    ...resourceParts,
+    ...urlMediaParts,
+    ...rememberedMediaParts
   ];
   const allLabels = [
     ...scopedMentionLabels,
     ...contentLabelsForDisplay,
-    ...resourceLabels
+    ...resourceLabels,
+    ...urlMediaLabels,
+    ...rememberedMediaRefs.map((ref) => `${ref.pathName} (\u8BB0\u5FC6)`)
   ];
   return {
     processedQuery: processedQueryParts,
@@ -953,7 +1178,8 @@ ${messages.join("\n")}`;
     toolDisplays: [
       ...scopedMentionDisplays,
       ...fileDisplays,
-      ...resourceDisplays
+      ...resourceDisplays,
+      ...urlMediaDisplays
     ],
     filesRead: allLabels,
     recording: {

package/chunks/{chunk-NFXXBWSE.js → chunk-SU64336V.js}

@@ -5,13 +5,13 @@ import {
   readLocalBootId,
   readPidNamespaceId,
   readProcStartToken
-} from "./chunk-CH2YDT6X.js";
+} from "./chunk-YVYK3JYU.js";
 import {
   require_proper_lockfile
 } from "./chunk-MLXTMF7H.js";
 import {
   Storage
-} from "./chunk-ZAFYHRVY.js";
+} from "./chunk-ZYDMQCQP.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/chunk-TFDCK56Y.js

@@ -0,0 +1,154 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  atomicWriteFile
+} from "./chunk-CA63HYHU.js";
+import {
+  createDebugLogger
+} from "./chunk-ZYDMQCQP.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/omni/json-cache-file.ts
+init_esbuild_shims();
+import fs from "node:fs/promises";
+import path from "node:path";
+var fileOps = /* @__PURE__ */ new Map();
+function serializeFileOperation(key, fn) {
+  const prev = fileOps.get(key) ?? Promise.resolve();
+  const run = prev.then(fn, fn);
+  const settled = run.then(
+    () => {
+    },
+    () => {
+    }
+  );
+  fileOps.set(key, settled);
+  void settled.then(() => {
+    if (fileOps.get(key) === settled) fileOps.delete(key);
+  });
+  return run;
+}
+__name(serializeFileOperation, "serializeFileOperation");
+var MAX_CORRUPT_BACKUPS = 2;
+var OmniJsonCacheFile = class {
+  constructor(filePath, debugChannel) {
+    this.filePath = filePath;
+    this.debugLogger = createDebugLogger(debugChannel);
+  }
+  static {
+    __name(this, "OmniJsonCacheFile");
+  }
+  debugLogger;
+  /**
+   * Run one serialized operation against the entry map. `fn` returns the
+   * operation result plus whether it changed the map (triggering an
+   * atomic save). When the file exists but cannot be read,
+   * `unreadableResult` is returned and nothing is saved.
+   */
+  async access(unreadableResult, fn) {
+    return serializeFileOperation(this.filePath, async () => {
+      const data = await this.load();
+      if (!data) return unreadableResult;
+      const { result, changed } = await fn(data.entries);
+      if (changed) await this.save(data);
+      return result;
+    });
+  }
+  /**
+   * Load the cache file. Returns null when the file exists but could not
+   * be read (EACCES, EMFILE, …): the caller must skip its operation for
+   * this call — proceeding with an empty snapshot and later saving it
+   * would overwrite N valid entries with one (self-inflicted cache wipe).
+   * Only a genuinely missing file means empty-and-writable.
+   */
+  async load() {
+    let raw;
+    try {
+      raw = await fs.readFile(this.filePath, "utf8");
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT" || code === "ENOTDIR") {
+        return { version: 1, entries: {} };
+      }
+      this.debugLogger.debug(
+        `cache read failed, operation skipped: ${err instanceof Error ? err.message : err}`
+      );
+      return null;
+    }
+    try {
+      const parsed = JSON.parse(raw);
+      if (parsed?.version === 1 && typeof parsed.entries === "object" && parsed.entries !== null && !Array.isArray(parsed.entries)) {
+        let pruned = 0;
+        for (const [k, v] of Object.entries(parsed.entries)) {
+          if (typeof v !== "object" || v === null || Array.isArray(v)) {
+            delete parsed.entries[k];
+            pruned++;
+          }
+        }
+        if (pruned > 0) {
+          this.debugLogger.debug(
+            `dropped ${pruned} malformed cache entr${pruned === 1 ? "y" : "ies"} from ${this.filePath}`
+          );
+        }
+        return parsed;
+      }
+      throw new Error("unexpected shape");
+    } catch {
+      const backup = `${this.filePath}.corrupt-${Date.now()}`;
+      await fs.rename(this.filePath, backup).catch(() => {
+      });
+      await this.pruneCorruptBackups();
+      this.debugLogger.debug(`corrupt cache backed up to ${backup}`);
+      return { version: 1, entries: {} };
+    }
+  }
+  /** Best-effort: keep only the newest {@link MAX_CORRUPT_BACKUPS}. */
+  async pruneCorruptBackups() {
+    const dir = path.dirname(this.filePath);
+    const prefix = `${path.basename(this.filePath)}.corrupt-`;
+    try {
+      const backups = (await fs.readdir(dir)).filter((n) => n.startsWith(prefix)).sort().reverse();
+      for (const name of backups.slice(MAX_CORRUPT_BACKUPS)) {
+        await fs.rm(path.join(dir, name), { force: true }).catch(() => {
+        });
+      }
+    } catch {
+    }
+  }
+  async save(data) {
+    try {
+      await fs.mkdir(path.dirname(this.filePath), {
+        recursive: true,
+        mode: 448
+      });
+      await atomicWriteFile(this.filePath, JSON.stringify(data, null, 1), {
+        mode: 384,
+        forceMode: true,
+        // Rename-replacement semantics: a symlink planted at the cache
+        // path is REPLACED by the rename, never written through — without
+        // this the default symlink resolution would redirect the write
+        // (and the 0600 chmod) onto the link's target.
+        noFollow: true
+      });
+    } catch (err) {
+      this.debugLogger.debug(
+        `cache write failed: ${err instanceof Error ? err.message : err}`
+      );
+    }
+  }
+};
+
+export {
+  serializeFileOperation,
+  OmniJsonCacheFile
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-JRHKM3YQ.js → chunk-TS4JJ7NN.js}

@@ -2,10 +2,10 @@
 "use strict";
 import {
   MAX_INLINE_IMAGE_ENCODED_LENGTH
-} from "./chunk-C4HBZQNH.js";
+} from "./chunk-U3MTHCJF.js";
 import {
   MAX_TERMINAL_IMAGE_BYTES
-} from "./chunk-RSWBT7AZ.js";
+} from "./chunk-VPGRGNNH.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-C4HBZQNH.js → chunk-U3MTHCJF.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   MAX_TERMINAL_IMAGE_BYTES
-} from "./chunk-RSWBT7AZ.js";
+} from "./chunk-VPGRGNNH.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";