@qwen-code/qwen-code 0.19.8 → 0.19.9-preview.0

package/chunks/{channel-worker-supervisor-NZQUOEFJ.js → chunk-B7MFJBKE.js}

@@ -7,21 +7,31 @@ import {
   QWEN_DAEMON_URL_ENV,
   QWEN_DAEMON_WORKSPACE_ENV,
   QWEN_SERVER_TOKEN_ENV
-} from "./chunk-S6RLAIUR.js";
+} from "./chunk-GYTKQYDB.js";
 import {
   channelSelectionNames
-} from "./chunk-MX2YXRER.js";
-import {
-  sanitizeLogText
-} from "./chunk-IBY3Q3HG.js";
-import "./chunk-VRDMOSQS.js";
+} from "./chunk-TJTKSVIV.js";
 import {
   redactLogCredentials
-} from "./chunk-HLKG6CZN.js";
-import "./chunk-K5PGHDBN.js";
+} from "./chunk-M5GB774H.js";
+import {
+  CHANNEL_WORKER_KILL_GRACE_MS,
+  CHANNEL_WORKER_STARTUP_TIMEOUT_MS,
+  CHANNEL_WORKER_STOP_GRACE_MS
+} from "./chunk-5HBA2Z7V.js";
+import {
+  CHANNEL_WEBHOOK_TASK_IPC_TIMEOUT_MS,
+  ChannelWebhookEnqueueError,
+  createChannelWebhookTaskMessage,
+  isChannelWebhookEnqueueErrorCode,
+  isChannelWebhookTaskResultMessage
+} from "./chunk-OJAMDVF5.js";
+import {
+  sanitizeLogText
+} from "./chunk-AU4R7ACM.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __name
 } from "./chunk-J2S4EL5Y.js";
@@ -30,7 +40,6 @@ import {
 init_esbuild_shims();
 import { fork } from "node:child_process";
 import { randomUUID } from "node:crypto";
-var DEFAULT_CHANNEL_WORKER_STARTUP_TIMEOUT_MS = 3e4;
 var DEFAULT_CHANNEL_WORKER_HEARTBEAT_TIMEOUT_MS = 45e3;
 var MAX_WORKER_LOG_LINE_LENGTH = 4096;
 var MAX_WORKER_LOG_BUFFER_LENGTH = 64 * 1024;
@@ -41,6 +50,15 @@ var ANSI_CSI_SEQUENCE_RE = new RegExp(
 );
 var WORKER_LOG_INVISIBLE_RE = new RegExp("[\\p{Cf}\\u2028\\u2029]|\\p{Variation_Selector}", "gu");
 var WORKER_LOG_CONTROL_RE = /[\x00-\x08\x0a-\x1f\x7f]/g;
+var ChannelWorkerStopError = class extends Error {
+  static {
+    __name(this, "ChannelWorkerStopError");
+  }
+  constructor(message = "Channel worker did not exit after SIGKILL.") {
+    super(message);
+    this.name = "ChannelWorkerStopError";
+  }
+};
 var DEFAULT_RESTART_POLICY = {
   maxRestarts: 3,
   windowMs: 5 * 6e4,
@@ -112,15 +130,17 @@ __name(notifyLog, "notifyLog");
 function waitForExit(child, timeoutMs) {
   return new Promise((resolve) => {
     let settled = false;
+    const onExit = /* @__PURE__ */ __name(() => done(true), "onExit");
     const done = /* @__PURE__ */ __name((exited) => {
       if (settled) return;
       settled = true;
-      if (timer) clearTimeout(timer);
+      clearTimeout(timer);
+      child.removeListener("exit", onExit);
       resolve(exited);
     }, "done");
     const timer = setTimeout(() => done(false), timeoutMs);
     timer.unref();
-    child.once("exit", () => done(true));
+    child.once("exit", onExit);
   });
 }
 __name(waitForExit, "waitForExit");
@@ -129,7 +149,7 @@ function hasObservedExit(snapshot) {
 }
 __name(hasObservedExit, "hasObservedExit");
 function createWorkerEnv(opts) {
-  const env = { ...process.env };
+  const env = { ...opts.baseEnv ?? process.env };
   env["QWEN_CODE_NO_RELAUNCH"] = "true";
   env[CHANNEL_DAEMON_WORKER_SENTINEL] = randomUUID();
   env[QWEN_DAEMON_URL_ENV] = opts.daemonUrl;
@@ -268,6 +288,9 @@ function createChannelWorkerSupervisor(opts) {
   let restartTimer;
   let staleHeartbeatTimer;
   let restartAttemptTimes = [];
+  const pendingWebhookTasks = /* @__PURE__ */ new Map();
+  let restarting;
+  let disposed = false;
   const snapshotCopy = /* @__PURE__ */ __name(() => ({
     ...snapshot,
     channels: [...snapshot.channels],
@@ -289,6 +312,40 @@ function createChannelWorkerSupervisor(opts) {
     clearTimeout(staleHeartbeatTimer);
     staleHeartbeatTimer = void 0;
   }, "clearStaleHeartbeatTimer");
+  const rejectPendingWebhookTasks = /* @__PURE__ */ __name((code, message) => {
+    for (const pending of pendingWebhookTasks.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(new ChannelWebhookEnqueueError(code, message));
+    }
+    pendingWebhookTasks.clear();
+  }, "rejectPendingWebhookTasks");
+  const rejectPendingWebhookTask = /* @__PURE__ */ __name((id, err) => {
+    const pending = pendingWebhookTasks.get(id);
+    if (!pending) return;
+    pendingWebhookTasks.delete(id);
+    clearTimeout(pending.timer);
+    pending.reject(err);
+  }, "rejectPendingWebhookTask");
+  const settleWebhookTask = /* @__PURE__ */ __name((message) => {
+    if (!isChannelWebhookTaskResultMessage(message)) return false;
+    const pending = pendingWebhookTasks.get(message.id);
+    if (!pending) return true;
+    if (message.ok) {
+      pendingWebhookTasks.delete(message.id);
+      clearTimeout(pending.timer);
+      pending.resolve({ accepted: true });
+    } else {
+      const code = isChannelWebhookEnqueueErrorCode(message.code) ? message.code : "channel_webhook_enqueue_failed";
+      rejectPendingWebhookTask(
+        message.id,
+        new ChannelWebhookEnqueueError(
+          code,
+          message.error || "Channel webhook task failed."
+        )
+      );
+    }
+    return true;
+  }, "settleWebhookTask");
   const pruneRestartAttempts = /* @__PURE__ */ __name((nowMs) => {
     restartAttemptTimes = restartAttemptTimes.filter(
       (attemptMs) => nowMs - attemptMs < restartPolicy.windowMs
@@ -385,7 +442,8 @@ function createChannelWorkerSupervisor(opts) {
     const env = createWorkerEnv({
       daemonUrl: opts.daemonUrl,
       workspace: opts.workspace,
-      ...opts.daemonToken ? { daemonToken: opts.daemonToken } : {}
+      ...opts.daemonToken ? { daemonToken: opts.daemonToken } : {},
+      ...opts.workerBaseEnv ? { baseEnv: opts.workerBaseEnv } : {}
     });
     const redaction = workerLogRedactionOptions(opts.daemonToken, env);
     const requestedChannels = requestedChannelNames(opts.selection);
@@ -464,18 +522,27 @@ function createChannelWorkerSupervisor(opts) {
         cleanupLaunch();
         if (terminatingBeforeReady) return;
         terminatingBeforeReady = true;
-        const exited = waitForExit(startedChild, 2e3);
+        const exited = waitForExit(startedChild, CHANNEL_WORKER_KILL_GRACE_MS);
         startedChild.kill("SIGTERM");
         void exited.then(async (didExit) => {
           if (!didExit && child === startedChild && !exitObserved) {
-            const killed = waitForExit(startedChild, 2e3);
+            const killed = waitForExit(
+              startedChild,
+              CHANNEL_WORKER_KILL_GRACE_MS
+            );
             startedChild.kill("SIGKILL");
             if (!await killed && child === startedChild && !exitObserved) {
-              child = void 0;
-              if (kind === "restart" && !stopping) {
-                scheduleRestart();
-                notifyExit(opts.onExit, snapshotCopy());
-              }
+              stopping = true;
+              notifyLog(opts.onLog, {
+                stream: "stderr",
+                line: "Channel worker did not exit after SIGKILL; automatic restart is disabled."
+              });
+              snapshot = {
+                ...snapshot,
+                state: "failed",
+                error: snapshot.error ?? "Channel worker did not exit after SIGKILL."
+              };
+              notifyExit(opts.onExit, snapshotCopy());
             }
           }
         });
@@ -527,6 +594,9 @@ function createChannelWorkerSupervisor(opts) {
       }, "handleHeartbeat");
       function handleMessage(message) {
         if (child !== startedChild) return;
+        if (settleWebhookTask(message)) {
+          return;
+        }
         if (!ready && isReadyMessage(message)) {
           completeReady(message);
         } else if (isHeartbeatMessage(message)) {
@@ -546,6 +616,10 @@ function createChannelWorkerSupervisor(opts) {
           signal,
           snapshot.error ?? (ready ? void 0 : sanitizeWorkerError(message, redaction))
         );
+        rejectPendingWebhookTasks(
+          "channel_worker_unavailable",
+          "Channel worker exited."
+        );
         child = void 0;
         if ((ready || kind === "restart") && !stopping) {
           scheduleRestart();
@@ -578,7 +652,7 @@ function createChannelWorkerSupervisor(opts) {
       }
       __name(settleError, "settleError");
       startupTimer = setTimeout(() => {
-        const timeoutMs = opts.startupTimeoutMs ?? DEFAULT_CHANNEL_WORKER_STARTUP_TIMEOUT_MS;
+        const timeoutMs = opts.startupTimeoutMs ?? CHANNEL_WORKER_STARTUP_TIMEOUT_MS;
         const error = `Channel worker did not become ready within ${timeoutMs}ms.`;
         snapshot = {
           ...snapshot,
@@ -589,16 +663,24 @@ function createChannelWorkerSupervisor(opts) {
         if (child === startedChild) {
           terminateBeforeReady();
         }
-      }, opts.startupTimeoutMs ?? DEFAULT_CHANNEL_WORKER_STARTUP_TIMEOUT_MS);
+      }, opts.startupTimeoutMs ?? CHANNEL_WORKER_STARTUP_TIMEOUT_MS);
       startupTimer.unref();
       startedChild.on("message", handleMessage);
       startedChild.once("exit", settleExit);
       startedChild.once("error", settleError);
     });
   }, "launch");
-  return {
+  const supervisor = {
     async start() {
-      if (child) return;
+      if (disposed) return;
+      if (child) {
+        if (stopping) {
+          throw new ChannelWorkerStopError(
+            "Channel worker stop is not yet confirmed."
+          );
+        }
+        return;
+      }
       stopping = false;
       clearRestartTimer();
       restartAttemptTimes = [];
@@ -607,34 +689,54 @@ function createChannelWorkerSupervisor(opts) {
     async stop() {
       clearRestartTimer();
       clearStaleHeartbeatTimer();
+      rejectPendingWebhookTasks(
+        "channel_worker_unavailable",
+        "Channel worker stopped."
+      );
       if (!child || snapshot.state === "exited" || snapshot.state === "failed" && hasObservedExit(snapshot) || snapshot.state === "stopped") {
         child = void 0;
         snapshot = { ...snapshot, state: "stopped" };
         return;
       }
-      const exited = waitForExit(child, 5e3);
+      const stoppingChild = child;
+      const exited = waitForExit(stoppingChild, CHANNEL_WORKER_STOP_GRACE_MS);
       stopping = true;
-      child.kill("SIGTERM");
-      if (!await exited) {
-        const killed = waitForExit(child, 2e3);
-        child.kill("SIGKILL");
+      stoppingChild.kill("SIGTERM");
+      if (!await exited && child === stoppingChild) {
+        const killed = waitForExit(stoppingChild, CHANNEL_WORKER_KILL_GRACE_MS);
+        stoppingChild.kill("SIGKILL");
         if (!await killed) {
-          child = void 0;
-          stopping = false;
           snapshot = {
             ...snapshot,
             state: "failed",
-            signal: "SIGKILL",
             error: "Channel worker did not exit after SIGKILL."
           };
-          return;
+          throw new ChannelWorkerStopError();
         }
       }
       child = void 0;
       stopping = false;
       snapshot = { ...snapshot, state: "stopped" };
     },
+    async restart() {
+      if (disposed) return snapshotCopy();
+      restarting ??= (async () => {
+        try {
+          await supervisor.stop();
+          await supervisor.start();
+          return snapshotCopy();
+        } finally {
+          restarting = void 0;
+        }
+      })();
+      return restarting;
+    },
     killAllSync() {
+      disposed = true;
+      rejectPendingWebhookTasks(
+        "channel_worker_unavailable",
+        "Channel worker stopped."
+      );
       if (!child || snapshot.state === "exited" || snapshot.state === "failed" && hasObservedExit(snapshot) || snapshot.state === "stopped") {
         clearRestartTimer();
         clearStaleHeartbeatTimer();
@@ -656,10 +758,64 @@ function createChannelWorkerSupervisor(opts) {
     },
     snapshot() {
       return snapshotCopy();
+    },
+    async enqueueWebhookTask(task) {
+      const startedChild = child;
+      if (!startedChild || snapshot.state !== "running") {
+        throw new ChannelWebhookEnqueueError(
+          "channel_worker_unavailable",
+          "Channel worker is not running."
+        );
+      }
+      const send = startedChild.send;
+      if (!send) {
+        throw new ChannelWebhookEnqueueError(
+          "channel_worker_unavailable",
+          "Channel worker IPC send failed."
+        );
+      }
+      const message = createChannelWebhookTaskMessage(task);
+      return await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          pendingWebhookTasks.delete(message.id);
+          reject(
+            new ChannelWebhookEnqueueError(
+              "channel_webhook_enqueue_timeout",
+              "Channel webhook task IPC timed out."
+            )
+          );
+        }, CHANNEL_WEBHOOK_TASK_IPC_TIMEOUT_MS);
+        timer.unref();
+        pendingWebhookTasks.set(message.id, { resolve, reject, timer });
+        try {
+          send.call(startedChild, message, (err) => {
+            if (err) {
+              rejectPendingWebhookTask(
+                message.id,
+                new ChannelWebhookEnqueueError(
+                  "channel_worker_unavailable",
+                  `Channel worker IPC send failed: ${err.message}`
+                )
+              );
+            }
+          });
+        } catch (err) {
+          rejectPendingWebhookTask(
+            message.id,
+            new ChannelWebhookEnqueueError(
+              "channel_worker_unavailable",
+              `Channel worker IPC send failed: ${err instanceof Error ? err.message : String(err)}`
+            )
+          );
+        }
+      });
     }
   };
+  return supervisor;
 }
 __name(createChannelWorkerSupervisor, "createChannelWorkerSupervisor");
+
 export {
+  ChannelWorkerStopError,
   createChannelWorkerSupervisor
 };

package/chunks/{chunk-HW4N45EE.js → chunk-B7NUUEXC.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __name
 } from "./chunk-J2S4EL5Y.js";
@@ -12,6 +12,17 @@ init_esbuild_shims();
 var DEFAULT_TOKEN_LIMIT = 2e5;
 var DEFAULT_OUTPUT_TOKEN_LIMIT = 32e3;
 var ESCALATED_MAX_TOKENS = 64e3;
+var OUTPUT_TOKEN_CEILING = ESCALATED_MAX_TOKENS;
+var MIN_CLAMPED_OUTPUT_TOKENS = 4e3;
+function outputClampMargin(contextWindowSize) {
+  return Math.max(1e4, Math.round(0.05 * contextWindowSize));
+}
+__name(outputClampMargin, "outputClampMargin");
+function clampOutputTokensToWindow(outputCeiling, contextWindowSize, promptTokens) {
+  const room = contextWindowSize - promptTokens - outputClampMargin(contextWindowSize);
+  return Math.min(outputCeiling, Math.max(MIN_CLAMPED_OUTPUT_TOKENS, room));
+}
+__name(clampOutputTokensToWindow, "clampOutputTokensToWindow");
 function parsePositiveIntegerEnvValue(raw) {
   if (raw === void 0) return void 0;
   const trimmed = raw.trim();
@@ -80,6 +91,8 @@ var PATTERNS = [
   // -------------------
   // Anthropic Claude
   // -------------------
+  [/^claude-opus-4-(?:6|7|8)/, LIMITS["1m"]],
+  // Opus 4.6-4.8: 1M
   [/^claude-/, LIMITS["200k"]],
   // All Claude models: 200K
   // -------------------
@@ -96,7 +109,7 @@ var PATTERNS = [
   [/^qwen3-max/, LIMITS["256k"]],
   // Open-source Qwen3 variants: 256K native
   [/^qwen3-coder-/, LIMITS["256k"]],
-  // Qwen fallback (VL, turbo, plus, 2.5, etc.): 128K
+  // Qwen fallback (VL, turbo, plus, 2.5, etc.): 256K
   [/^qwen/, LIMITS["256k"]],
   // -------------------
   // DeepSeek
@@ -149,8 +162,8 @@ var OUTPUT_PATTERNS = [
   [/^o\d/, LIMITS["128k"]],
   // o-series: 128K
   // Anthropic Claude
-  [/^claude-opus-4-6/, LIMITS["128k"]],
-  // Opus 4.6: 128K
+  [/^claude-opus-4-(?:6|7|8)/, 128e3],
+  // Opus 4.6-4.8: 128K
   [/^claude-sonnet-4-6/, LIMITS["64k"]],
   // Sonnet 4.6: 64K
   [/^claude-/, LIMITS["64k"]],
@@ -190,12 +203,6 @@ function hasExplicitOutputLimit(model) {
   return OUTPUT_PATTERNS.some(([regex]) => regex.test(norm));
 }
 __name(hasExplicitOutputLimit, "hasExplicitOutputLimit");
-function escalatedOutputTokenLimit(model, contextWindowSize) {
-  const escalated = Math.max(ESCALATED_MAX_TOKENS, tokenLimit(model, "output"));
-  const window = contextWindowSize !== void 0 && contextWindowSize > 0 ? contextWindowSize : DEFAULT_TOKEN_LIMIT;
-  return Math.min(escalated, Math.floor(window / 2));
-}
-__name(escalatedOutputTokenLimit, "escalatedOutputTokenLimit");
 function knownTokenLimit(model, type = "input") {
   return findTokenLimit(model, type);
 }
@@ -204,6 +211,21 @@ function tokenLimit(model, type = "input") {
   return knownTokenLimit(model, type) ?? (type === "output" ? DEFAULT_OUTPUT_TOKEN_LIMIT : DEFAULT_TOKEN_LIMIT);
 }
 __name(tokenLimit, "tokenLimit");
+function defaultOutputCeiling(model) {
+  const outputLimit = tokenLimit(model, "output");
+  if (/^claude-opus-4-(?:6|7|8)/.test(normalize(model))) {
+    return outputLimit;
+  }
+  return Math.min(outputLimit, OUTPUT_TOKEN_CEILING);
+}
+__name(defaultOutputCeiling, "defaultOutputCeiling");
+function reconcileMaxTokens(configMaxTokens, requestMaxTokens) {
+  if (typeof configMaxTokens === "number" && typeof requestMaxTokens === "number") {
+    return Math.min(configMaxTokens, requestMaxTokens);
+  }
+  return void 0;
+}
+__name(reconcileMaxTokens, "reconcileMaxTokens");
 
 // packages/core/src/core/openaiContentGenerator/constants.ts
 init_esbuild_shims();
@@ -258,12 +280,17 @@ export {
   DEFAULT_TOKEN_LIMIT,
   DEFAULT_OUTPUT_TOKEN_LIMIT,
   ESCALATED_MAX_TOKENS,
+  OUTPUT_TOKEN_CEILING,
+  MIN_CLAMPED_OUTPUT_TOKENS,
+  outputClampMargin,
+  clampOutputTokensToWindow,
   parsePositiveIntegerEnvValue,
   normalize,
   hasExplicitOutputLimit,
-  escalatedOutputTokenLimit,
   knownTokenLimit,
   tokenLimit,
+  defaultOutputCeiling,
+  reconcileMaxTokens,
   resolveRequestTimeout,
   DEFAULT_STREAM_IDLE_TIMEOUT_MS,
   QWEN_STREAM_IDLE_TIMEOUT_MS_ENV,

package/chunks/{chunk-3B26UVCX.js → chunk-BLPMRN4B.js}

@@ -4,10 +4,10 @@ import {
   matches,
   nextFireTime,
   parseCron
-} from "./chunk-2MPVVENX.js";
+} from "./chunk-XU457J4V.js";
 import {
   humanReadableCron
-} from "./chunk-ZTQ26VBE.js";
+} from "./chunk-VDDGDZMA.js";
 import {
   CRON_TASKS_DISPLAY_PATH,
   addCronTask,
@@ -16,19 +16,21 @@ import {
   getCronFilePath,
   readCronTasks,
   removeCronTasks,
+  taskHasLegacyCondition,
+  taskHasLegacyRunMode,
   updateCronTasks
-} from "./chunk-FV7425LN.js";
+} from "./chunk-SPJQO2CE.js";
 import {
   ToolNames
-} from "./chunk-X3YGAX7V.js";
+} from "./chunk-JGUT3LWZ.js";
 import {
   Storage,
   createDebugLogger,
   getProjectHash
-} from "./chunk-22MNNNXE.js";
+} from "./chunk-7NFB7LBQ.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __name
 } from "./chunk-J2S4EL5Y.js";
@@ -283,6 +285,13 @@ var CronScheduler = class {
   // the live job away (or clear its pendingRemoval guard) as if it had
   // been deleted on disk.
   pendingAdd = /* @__PURE__ */ new Set();
+  // Ids of legacy tasks (a pre-removal `isolated` task with a `condition`
+  // precondition) already reported as skipped, so the fail-closed remediation
+  // breadcrumb is logged once per task rather than on every file reload.
+  warnedLegacyConditionIds = /* @__PURE__ */ new Set();
+  // Ids of bare `runMode: 'isolated'` legacy tasks already warned about — they
+  // still run (no safety gate), so this is a one-time behavior-change notice.
+  warnedLegacyRunModeIds = /* @__PURE__ */ new Set();
   // Durable ids whose lastFiredAt persist is in flight after a fire — the tick
   // (on-time) OR a catch-up delivery. A reload racing that async write reads the
   // stale disk stamp, so it must not re-detect and re-fire the same slot. Only
@@ -597,9 +606,25 @@ var CronScheduler = class {
     if (generation !== this.durableGeneration) {
       return;
     }
-    const tasks = read.filter(
-      (t) => hasParseableCron(t) && t.enabled !== false
-    );
+    const tasks = read.filter((t) => {
+      if (!hasParseableCron(t) || t.enabled === false) return false;
+      if (taskHasLegacyCondition(t)) {
+        if (!this.warnedLegacyConditionIds.has(t.id)) {
+          this.warnedLegacyConditionIds.add(t.id);
+          console.warn(
+            `CronScheduler: scheduled task ${t.id} carries a legacy precondition (isolated run mode was removed) and will NOT fire \u2014 recreate it if you still want it to run.`
+          );
+        }
+        return false;
+      }
+      if (taskHasLegacyRunMode(t) && !this.warnedLegacyRunModeIds.has(t.id)) {
+        this.warnedLegacyRunModeIds.add(t.id);
+        console.warn(
+          `CronScheduler: scheduled task ${t.id} was created with the removed 'isolated' run mode; it now runs in its bound session (history accumulates across runs). Recreate it and call create_sub_session from the prompt for per-run isolation.`
+        );
+      }
+      return true;
+    });
     const now = Date.now();
     const missedOneShots = [];
     const catchUpIds = [];
@@ -713,8 +738,12 @@ var CronScheduler = class {
         });
         for (const id of skipped) this.pendingRemoval.delete(id);
         if (runnable.length > 0) {
+          const carrier = durableTaskToJob(
+            runnable[0],
+            this.recurringMaxAgeMs
+          );
           onFire({
-            ...durableTaskToJob(runnable[0], this.recurringMaxAgeMs),
+            ...carrier,
             prompt: buildMissedCronNotification(runnable),
             missed: true
           });

package/chunks/{chunk-ZN5T4BHI.js → chunk-BPZALHVR.js}

@@ -2,10 +2,10 @@
 "use strict";
 import {
   require_lib
-} from "./chunk-IRJWHZWU.js";
+} from "./chunk-A4UCTEB5.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __commonJS,
   __name,