@qwen-code/qwen-code 0.23.5-preview.0 → 0.24.0-nightly.20260916.b8def02aad

package/chunks/chunk-WL2V7PTE.js

@@ -0,0 +1,78 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  appendOmniUsageLog,
+  parseSseCompletion
+} from "./chunk-IVPSLX4P.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/omni/policy/tools/omni-chat-request.ts
+init_esbuild_shims();
+function serializeMediaPart(part) {
+  switch (part.type) {
+    case "image_url":
+      return { type: "image_url", image_url: { url: part.url } };
+    case "video_url":
+      return { type: "video_url", video_url: { url: part.url } };
+    case "input_audio":
+      return {
+        type: "input_audio",
+        input_audio: { data: part.data, format: part.format }
+      };
+    default: {
+      const exhaustive = part;
+      throw new Error(`unknown media part type ${String(exhaustive)}`);
+    }
+  }
+}
+__name(serializeMediaPart, "serializeMediaPart");
+async function requestOmniChatCompletion(options) {
+  const requestSignal = AbortSignal.any([
+    options.signal,
+    AbortSignal.timeout(options.timeoutMs)
+  ]);
+  const content = [
+    ...options.media.map(serializeMediaPart),
+    { type: "text", text: options.prompt }
+  ];
+  const response = await fetch(
+    `${options.baseUrl.replace(/\/+$/, "")}/chat/completions`,
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${options.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        model: options.model,
+        modalities: ["text"],
+        stream: true,
+        stream_options: { include_usage: true },
+        messages: [{ role: "user", content }],
+        ...options.maxTokens !== void 0 ? { max_tokens: options.maxTokens } : {}
+      }),
+      signal: requestSignal
+    }
+  );
+  if (!response.ok) {
+    return { ok: false, error: `HTTP ${response.status}` };
+  }
+  const { text, usage } = parseSseCompletion(await response.text());
+  appendOmniUsageLog(options.model, usage, options.tool);
+  return { ok: true, text: text.trim() };
+}
+__name(requestOmniChatCompletion, "requestOmniChatCompletion");
+
+export {
+  requestOmniChatCompletion
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-TPY6HW55.js → chunk-WVA7RUOL.js}

@@ -2,26 +2,29 @@
 "use strict";
 import {
   t
-} from "./chunk-GSAOVDTH.js";
+} from "./chunk-POMFSBEC.js";
 import {
   computeThresholds,
   estimateContextTextTokens,
   formatContextFileDisplayPath,
   getMainSessionBaseSystemPrompt
-} from "./chunk-KAYC5FBN.js";
+} from "./chunk-B32X6MSB.js";
+import {
+  isMediaPolicyToolHiddenFromModel
+} from "./chunk-MNU36NGH.js";
 import {
   buildSkillLlmContent
-} from "./chunk-WBSJ6VPZ.js";
+} from "./chunk-2GNZTJRK.js";
 import {
   DiscoveredMCPTool,
   uiTelemetryService
-} from "./chunk-CDDP4ONL.js";
+} from "./chunk-2RI3OGVU.js";
 import {
   DEFAULT_TOKEN_LIMIT
-} from "./chunk-GJKP6XOB.js";
+} from "./chunk-4EFJT6Q2.js";
 import {
   ToolNames
-} from "./chunk-RSWBT7AZ.js";
+} from "./chunk-ERIBG3BX.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -89,6 +92,9 @@ async function collectContextData(config, showDetails) {
     if (toolRegistry?.isDeferredAndHidden(tool.name)) {
       continue;
     }
+    if (isMediaPolicyToolHiddenFromModel(config, tool)) {
+      continue;
+    }
     const toolJsonStr = JSON.stringify(tool.schema);
     const tokens = estimateContextTextTokens(toolJsonStr);
     if (tool instanceof DiscoveredMCPTool) {

package/chunks/{chunk-OSG23MR3.js → chunk-X3T5IOX6.js}

@@ -2,10 +2,10 @@
 "use strict";
 import {
   wrapForMultiplexer
-} from "./chunk-DC4ZNGH4.js";
+} from "./chunk-6DB6UHY3.js";
 import {
   createDebugLogger
-} from "./chunk-ZAFYHRVY.js";
+} from "./chunk-ZYDMQCQP.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-D7JMO2GP.js → chunk-XCP5Y2RZ.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   skillRestrictionNames
-} from "./chunk-P42KMMU6.js";
+} from "./chunk-XYJNMSMV.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-VU3XMZ5I.js → chunk-XEVYHNTL.js}

@@ -2,11 +2,11 @@
 "use strict";
 import {
   multiSessionCompatibilityError
-} from "./chunk-SYMXYRM5.js";
+} from "./chunk-W7JWIIRC.js";
 import {
   UNSAFE_OBJECT_KEYS,
   getPlugin
-} from "./chunk-U4AASWUQ.js";
+} from "./chunk-L4GF4IK2.js";
 import {
   CHANNEL_OUTPUT_MODE_FIELD,
   parseChannelOutputMode
@@ -14,7 +14,7 @@ import {
 import {
   loadSettings,
   saveSettings
-} from "./chunk-RRI764F7.js";
+} from "./chunk-ZA5CZSKV.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-UQGRJTDK.js → chunk-XWYDOF7F.js}

@@ -8,13 +8,13 @@ import {
 } from "./chunk-TXASDT2M.js";
 import {
   t
-} from "./chunk-GSAOVDTH.js";
+} from "./chunk-POMFSBEC.js";
 import {
   So
-} from "./chunk-KAYC5FBN.js";
+} from "./chunk-B32X6MSB.js";
 import {
   createDebugLogger
-} from "./chunk-ZAFYHRVY.js";
+} from "./chunk-ZYDMQCQP.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-OZEV3R3S.js → chunk-XYAB5R6E.js}

@@ -2,14 +2,14 @@
 "use strict";
 import {
   theme
-} from "./chunk-4LIPOIXS.js";
+} from "./chunk-3NHJLWOD.js";
 import {
   require_jsx_runtime
 } from "./chunk-SV5PQVQE.js";
 import {
   Box_default,
   Text
-} from "./chunk-NCPFOLM2.js";
+} from "./chunk-ZTBP4SFC.js";
 import {
   require_react
 } from "./chunk-5QWWOFGG.js";
@@ -21,7 +21,7 @@ import {
 } from "./chunk-2MIN6GRR.js";
 import {
   createDebugLogger
-} from "./chunk-ZAFYHRVY.js";
+} from "./chunk-ZYDMQCQP.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-P42KMMU6.js → chunk-XYJNMSMV.js}

@@ -5,14 +5,14 @@ import {
 } from "./chunk-MLXTMF7H.js";
 import {
   stringifyGenAiJson
-} from "./chunk-KFFCDLKV.js";
+} from "./chunk-QE36VXWP.js";
 import {
   GOAL_STATE_EVENT_CAUSES,
   makeGoalStateEvent
-} from "./chunk-CDDP4ONL.js";
+} from "./chunk-2RI3OGVU.js";
 import {
   atomicWriteJSON
-} from "./chunk-XFFRI3WM.js";
+} from "./chunk-CA63HYHU.js";
 import {
   DEFAULT_SENSITIVE_SPAN_ATTRIBUTE_MAX_LENGTH,
   SENSITIVE_SPAN_ATTRIBUTE_MAX_LENGTH_LIMIT,
@@ -20,12 +20,14 @@ import {
   getMeter,
   isTelemetrySdkInitialized,
   isValidSensitiveSpanAttributeMaxLength
-} from "./chunk-6USYH3EU.js";
+} from "./chunk-B3XJFEEH.js";
 import {
-  FatalConfigError,
   QWEN_DIR,
   createDebugLogger
-} from "./chunk-ZAFYHRVY.js";
+} from "./chunk-ZYDMQCQP.js";
+import {
+  FatalConfigError
+} from "./chunk-S34QJ6IR.js";
 import {
   ValueType,
   diag,
@@ -7854,6 +7856,16 @@ __name(goalPauseReasonForRunBudget, "goalPauseReasonForRunBudget");
 
 // packages/core/src/goals/goal-reducer.ts
 var MAX_BLOCKED_AUDIT_COUNT = 3;
+function reduceGoalSpend(goal, tokens, now) {
+  if (!Number.isFinite(tokens) || tokens <= 0) return goal;
+  return {
+    ...goal,
+    tokensUsed: goal.tokensUsed + tokens,
+    activeTimeMs: elapsedActiveTime(goal, now),
+    updatedAt: now
+  };
+}
+__name(reduceGoalSpend, "reduceGoalSpend");
 var GoalConflictError = class extends Error {
   constructor(current) {
     super("Goal version does not match the current session Goal");
@@ -10412,6 +10424,7 @@ export {
   goalPauseReasonForFailure,
   goalPauseReasonForHeadlessFailure,
   goalPauseReasonForRunBudget,
+  reduceGoalSpend,
   GoalConflictError,
   GoalInvalidTransitionError,
   elapsedActiveTime,

package/chunks/chunk-XZA32HII.js

@@ -0,0 +1,19 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+
+// packages/core/src/utils/default-qwen-model.ts
+init_esbuild_shims();
+var DEFAULT_QWEN_MODEL = "coder-model";
+
+export {
+  DEFAULT_QWEN_MODEL
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-4FLUQWJ4.js → chunk-Y3Q5OK4D.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-CQ35AJ4Z.js";
 import {
   AuthType
-} from "./chunk-7O5PYQ3M.js";
+} from "./chunk-SBP43AO6.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-ZFHKUQZ4.js → chunk-Y45AQRB2.js}

@@ -2,21 +2,21 @@
 "use strict";
 import {
   appEvents
-} from "./chunk-CXY6BICQ.js";
+} from "./chunk-6COTLZAO.js";
 import {
   assembleMcpServers,
   getPendingGatedMcpServers,
   getPromptableMcpServers
-} from "./chunk-WL36KHUQ.js";
+} from "./chunk-2CWJJ454.js";
 import {
   getMCPServerStatus
-} from "./chunk-CDDP4ONL.js";
+} from "./chunk-2RI3OGVU.js";
 import {
   require_fast_deep_equal
-} from "./chunk-RSWBT7AZ.js";
+} from "./chunk-ERIBG3BX.js";
 import {
   createDebugLogger
-} from "./chunk-ZAFYHRVY.js";
+} from "./chunk-ZYDMQCQP.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-SFHX5G2S.js → chunk-Y5KOKTSF.js}

@@ -25,46 +25,46 @@ import {
   rebuildToolRegistryOnOverride,
   resolveExternalWorktreeDir,
   toModelVisibleSubagentResult
-} from "./chunk-KAYC5FBN.js";
-import {
-  parsePositiveIntegerEnv
-} from "./chunk-6PVPNMXU.js";
+} from "./chunk-B32X6MSB.js";
 import {
   GitWorktreeService,
   generateAgentWorktreeSlug,
   writeWorktreeSessionMarker
-} from "./chunk-CXONOVBN.js";
+} from "./chunk-KS6F6LZQ.js";
+import {
+  parsePositiveIntegerEnv
+} from "./chunk-6PVPNMXU.js";
 import {
   resolveBundleDir
 } from "./chunk-ACHCT36C.js";
 import {
   SUBAGENT_PLAN_LIFECYCLE_TOOLS
-} from "./chunk-AEWCOE64.js";
+} from "./chunk-GACWUBXV.js";
 import {
   runWithAgentContext
-} from "./chunk-BW2SMO6L.js";
+} from "./chunk-BXAU2UKM.js";
 import {
   read,
   uiTelemetryService,
   writeLine
-} from "./chunk-CDDP4ONL.js";
+} from "./chunk-2RI3OGVU.js";
 import {
   REASONING_EFFORT_TIERS,
   normalizeReasoningEffort
-} from "./chunk-GJKP6XOB.js";
+} from "./chunk-4EFJT6Q2.js";
 import {
   stripAnsiAndControl
-} from "./chunk-6USYH3EU.js";
+} from "./chunk-B3XJFEEH.js";
 import {
   SyntheticOutputTool
-} from "./chunk-SYROIHU7.js";
+} from "./chunk-ZRQGTRHA.js";
 import {
   ToolNames,
   resolveBuiltinToolName
-} from "./chunk-RSWBT7AZ.js";
+} from "./chunk-ERIBG3BX.js";
 import {
   createDebugLogger
-} from "./chunk-ZAFYHRVY.js";
+} from "./chunk-ZYDMQCQP.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -921,7 +921,7 @@ function terminalDispatchError(workflowAgentId, mode) {
 }
 __name(terminalDispatchError, "terminalDispatchError");
 async function runSingleDispatch(config, prompt, opts, attemptSignal, emitter, workflowAgentId, agentIdentity, onTokens, subagentBounds) {
-  const { AgentHeadless, ContextState } = await import("./agent-headless-EJ4QOUSM.js");
+  const { AgentHeadless, ContextState } = await import("./agent-headless-QE53TJVO.js");
   const ctx = new ContextState();
   ctx.set("task_prompt", prompt);
   debugLogger.debug(`[workflow] Dispatch ${workflowAgentId}`);

package/chunks/chunk-YDERQ7ZV.js

@@ -0,0 +1,248 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  isPlainRecord
+} from "./chunk-BQMSZSG6.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/services/media-memory/config.ts
+init_esbuild_shims();
+var OmniMemoryConfigError = class extends Error {
+  static {
+    __name(this, "OmniMemoryConfigError");
+  }
+  constructor(message) {
+    super(message);
+    this.name = "OmniMemoryConfigError";
+  }
+};
+var OMNI_MEMORY_RECALL_KINDS = [
+  "metadata",
+  "derived_media",
+  "policy_result",
+  "execution"
+];
+var DEFAULT_OMNI_MEMORY_CONFIG = {
+  collection: { maxInlineTextBytes: 65536 },
+  recall: {
+    mode: "active",
+    maxEntries: 12,
+    maxTextChars: 24e3,
+    kinds: [...OMNI_MEMORY_RECALL_KINDS],
+    includeHistoricalVersions: false,
+    active: { maxFilesPerCall: 8 },
+    sideQuery: {
+      model: null,
+      timeoutMs: 3e4,
+      maxCandidateEntries: 100,
+      maxSelectedEntries: 12,
+      maxAttempts: 1
+    }
+  }
+};
+var ROOT_KEYS = /* @__PURE__ */ new Set(["collection", "recall"]);
+var COLLECTION_KEYS = /* @__PURE__ */ new Set(["maxInlineTextBytes"]);
+var RECALL_KEYS = /* @__PURE__ */ new Set([
+  "mode",
+  "maxEntries",
+  "maxTextChars",
+  "kinds",
+  "includeHistoricalVersions",
+  "active",
+  "sideQuery"
+]);
+var ACTIVE_KEYS = /* @__PURE__ */ new Set(["maxFilesPerCall"]);
+var SIDE_QUERY_KEYS = /* @__PURE__ */ new Set([
+  "model",
+  "timeoutMs",
+  "maxCandidateEntries",
+  "maxSelectedEntries",
+  "maxAttempts"
+]);
+function fail(message) {
+  throw new OmniMemoryConfigError(message);
+}
+__name(fail, "fail");
+function requireRecord(value, where, allowedKeys) {
+  if (!isPlainRecord(value)) {
+    fail(`${where}: must be an object (got ${JSON.stringify(value)})`);
+  }
+  for (const key of Object.keys(value)) {
+    if (!allowedKeys.has(key)) {
+      fail(
+        `${where}: unknown key "${key}" (allowed: ${[...allowedKeys].join(", ")})`
+      );
+    }
+  }
+  return value;
+}
+__name(requireRecord, "requireRecord");
+function positiveInteger(value, where) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+    fail(`${where}: must be a positive integer (got ${JSON.stringify(value)})`);
+  }
+  return value;
+}
+__name(positiveInteger, "positiveInteger");
+function requireBoolean(value, where) {
+  if (typeof value !== "boolean") {
+    fail(`${where}: must be a boolean (got ${JSON.stringify(value)})`);
+  }
+  return value;
+}
+__name(requireBoolean, "requireBoolean");
+function normalizeKinds(value, where) {
+  if (!Array.isArray(value) || value.length === 0) {
+    fail(`${where}: must be a non-empty array of entry kinds`);
+  }
+  const known = new Set(OMNI_MEMORY_RECALL_KINDS);
+  const seen = /* @__PURE__ */ new Set();
+  for (const kind of value) {
+    if (typeof kind !== "string" || !known.has(kind)) {
+      fail(
+        `${where}: unknown entry kind ${JSON.stringify(kind)} (allowed: ${OMNI_MEMORY_RECALL_KINDS.join(", ")})`
+      );
+    }
+    if (seen.has(kind)) {
+      fail(`${where}: duplicate entry kind "${kind}"`);
+    }
+    seen.add(kind);
+  }
+  return [...seen];
+}
+__name(normalizeKinds, "normalizeKinds");
+function normalizeOmniMemoryConfig(raw) {
+  const defaults = DEFAULT_OMNI_MEMORY_CONFIG;
+  if (raw !== void 0) {
+    requireRecord(raw, "omni.memory", ROOT_KEYS);
+  }
+  let maxInlineTextBytes = defaults.collection.maxInlineTextBytes;
+  if (raw?.collection !== void 0) {
+    const collection = requireRecord(
+      raw.collection,
+      "omni.memory.collection",
+      COLLECTION_KEYS
+    );
+    if (collection["maxInlineTextBytes"] !== void 0) {
+      maxInlineTextBytes = positiveInteger(
+        collection["maxInlineTextBytes"],
+        "omni.memory.collection.maxInlineTextBytes"
+      );
+    }
+  }
+  const recall = { ...defaults.recall };
+  recall.kinds = [...defaults.recall.kinds];
+  recall.active = { ...defaults.recall.active };
+  recall.sideQuery = { ...defaults.recall.sideQuery };
+  if (raw?.recall !== void 0) {
+    const rawRecall = requireRecord(
+      raw.recall,
+      "omni.memory.recall",
+      RECALL_KEYS
+    );
+    if (rawRecall["mode"] !== void 0) {
+      const mode = rawRecall["mode"];
+      if (mode !== "active" && mode !== "sideQuery") {
+        fail(
+          `omni.memory.recall.mode: must be "active" or "sideQuery" (got ${JSON.stringify(mode)})`
+        );
+      }
+      recall.mode = mode;
+    }
+    if (rawRecall["maxEntries"] !== void 0) {
+      recall.maxEntries = positiveInteger(
+        rawRecall["maxEntries"],
+        "omni.memory.recall.maxEntries"
+      );
+    }
+    if (rawRecall["maxTextChars"] !== void 0) {
+      recall.maxTextChars = positiveInteger(
+        rawRecall["maxTextChars"],
+        "omni.memory.recall.maxTextChars"
+      );
+    }
+    if (rawRecall["kinds"] !== void 0) {
+      recall.kinds = normalizeKinds(
+        rawRecall["kinds"],
+        "omni.memory.recall.kinds"
+      );
+    }
+    if (rawRecall["includeHistoricalVersions"] !== void 0) {
+      recall.includeHistoricalVersions = requireBoolean(
+        rawRecall["includeHistoricalVersions"],
+        "omni.memory.recall.includeHistoricalVersions"
+      );
+    }
+    if (rawRecall["active"] !== void 0) {
+      const active = requireRecord(
+        rawRecall["active"],
+        "omni.memory.recall.active",
+        ACTIVE_KEYS
+      );
+      if (active["maxFilesPerCall"] !== void 0) {
+        recall.active.maxFilesPerCall = positiveInteger(
+          active["maxFilesPerCall"],
+          "omni.memory.recall.active.maxFilesPerCall"
+        );
+      }
+    }
+    if (rawRecall["sideQuery"] !== void 0) {
+      const sq = requireRecord(
+        rawRecall["sideQuery"],
+        "omni.memory.recall.sideQuery",
+        SIDE_QUERY_KEYS
+      );
+      if (sq["model"] !== void 0) {
+        const model = sq["model"];
+        if (model !== null && (typeof model !== "string" || model === "")) {
+          fail(
+            `omni.memory.recall.sideQuery.model: must be null or a non-empty string (got ${JSON.stringify(model)})`
+          );
+        }
+        recall.sideQuery.model = model;
+      }
+      for (const key of [
+        "timeoutMs",
+        "maxCandidateEntries",
+        "maxSelectedEntries",
+        "maxAttempts"
+      ]) {
+        if (sq[key] !== void 0) {
+          recall.sideQuery[key] = positiveInteger(
+            sq[key],
+            `omni.memory.recall.sideQuery.${key}`
+          );
+        }
+      }
+    }
+  }
+  if (recall.sideQuery.maxSelectedEntries > recall.maxEntries) {
+    fail(
+      `omni.memory.recall.sideQuery.maxSelectedEntries (${recall.sideQuery.maxSelectedEntries}) must not exceed omni.memory.recall.maxEntries (${recall.maxEntries})`
+    );
+  }
+  if (recall.maxEntries > recall.sideQuery.maxCandidateEntries) {
+    fail(
+      `omni.memory.recall.maxEntries (${recall.maxEntries}) must not exceed omni.memory.recall.sideQuery.maxCandidateEntries (${recall.sideQuery.maxCandidateEntries})`
+    );
+  }
+  return { collection: { maxInlineTextBytes }, recall };
+}
+__name(normalizeOmniMemoryConfig, "normalizeOmniMemoryConfig");
+
+export {
+  OmniMemoryConfigError,
+  OMNI_MEMORY_RECALL_KINDS,
+  DEFAULT_OMNI_MEMORY_CONFIG,
+  normalizeOmniMemoryConfig
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-Y2KJC55Y.js → chunk-YGYIGZQC.js}

@@ -6,18 +6,18 @@ import {
 } from "./chunk-47ECGEJC.js";
 import {
   t
-} from "./chunk-GSAOVDTH.js";
+} from "./chunk-POMFSBEC.js";
 import {
   fetchGitDiff,
   isCompressionFailureStatus
-} from "./chunk-KAYC5FBN.js";
+} from "./chunk-B32X6MSB.js";
 import {
   skillRestrictionNames
-} from "./chunk-P42KMMU6.js";
+} from "./chunk-XYJNMSMV.js";
 import {
   findProviderByCredentials,
   resolveMetadataKey
-} from "./chunk-KEM7MWS7.js";
+} from "./chunk-VZQDBPCD.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-3XBUCOWS.js → chunk-YSD6IY6F.js}

@@ -2,11 +2,11 @@
 "use strict";
 import {
   ResponsesHttpError
-} from "./chunk-M4U2LTD2.js";
+} from "./chunk-MS4SXNJ6.js";
 import {
   getErrorStatus,
   isAbortError
-} from "./chunk-ZAFYHRVY.js";
+} from "./chunk-S34QJ6IR.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";