@qwen-code/qwen-code 0.23.1-preview.2 → 0.23.1

package/chunks/{chunk-WLZRMF3C.js → chunk-ZPL2TZNA.js}

@@ -23,10 +23,11 @@ import {
   SessionConflictError,
   SessionNotArchivedError,
   SessionNotFoundError
-} from "./chunk-F47DITLZ.js";
+} from "./chunk-FAWTMDX7.js";
 import {
-  readWorktreeSession
-} from "./chunk-E4VX6LXB.js";
+  readWorktreeSession,
+  readWorktreeSessionStrict
+} from "./chunk-YZTGGCEE.js";
 import {
   SESSION_PR_LIST_LIMIT,
   SESSION_PR_URL_MAX_LENGTH,
@@ -40,7 +41,12 @@ import {
   gitEnv,
   readSessionPrs,
   toSessionPrInfo
-} from "./chunk-TSLRORQR.js";
+} from "./chunk-PDUMGZ2P.js";
+import {
+  GitWorktreeService,
+  WORKTREE_SESSION_FILE,
+  readWorktreeSessionMarkerStrict
+} from "./chunk-HIXUUCGY.js";
 import {
   updateCronTasks
 } from "./chunk-F53KKZUD.js";
@@ -1322,6 +1328,7 @@ __name(createWorkspaceRuntimeSessionService, "createWorkspaceRuntimeSessionServi
 
 // packages/cli/src/serve/server/session-archive.ts
 init_esbuild_shims();
+import fs2 from "node:fs";
 
 // packages/cli/src/serve/scheduled-task-session-lifecycle.ts
 init_esbuild_shims();
@@ -1394,6 +1401,296 @@ async function removeTasksForSessions(projectRoot, sessionIds, options = {}) {
 }
 __name(removeTasksForSessions, "removeTasksForSessions");
 
+// packages/cli/src/serve/server/worktree-orphan-cleanup.ts
+init_esbuild_shims();
+import fs from "node:fs";
+import * as fsp from "node:fs/promises";
+import path2 from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+// packages/cli/src/serve/server/worktree-ownership-op.ts
+init_esbuild_shims();
+var worktreeOwnershipOpTails = /* @__PURE__ */ new Map();
+async function acquireWorktreeOwnershipOp(worktreeKey) {
+  const previous = worktreeOwnershipOpTails.get(worktreeKey);
+  let releaseGate;
+  const gate = new Promise((resolve) => {
+    releaseGate = resolve;
+  });
+  const tail = (previous ?? Promise.resolve()).then(() => gate);
+  worktreeOwnershipOpTails.set(worktreeKey, tail);
+  if (previous) {
+    await previous;
+  }
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    releaseGate();
+    if (worktreeOwnershipOpTails.get(worktreeKey) === tail) {
+      worktreeOwnershipOpTails.delete(worktreeKey);
+    }
+  };
+}
+__name(acquireWorktreeOwnershipOp, "acquireWorktreeOwnershipOp");
+
+// packages/cli/src/serve/server/worktree-orphan-cleanup.ts
+function canonicalPath(candidate) {
+  try {
+    return fs.realpathSync(candidate);
+  } catch {
+    return candidate;
+  }
+}
+__name(canonicalPath, "canonicalPath");
+var execFileAsync = promisify(execFile);
+var DISPOSABLE_IGNORED_ROOTS = /* @__PURE__ */ new Set(["node_modules", "dist", "coverage"]);
+async function checkoutHasWork(worktreePath) {
+  try {
+    const { stdout } = await execFileAsync(
+      "git",
+      [
+        "status",
+        "--porcelain",
+        "--untracked-files=normal",
+        "--ignored=matching"
+      ],
+      { cwd: worktreePath, env: gitEnv() }
+    );
+    return stdout.split("\n").filter((line) => line.trim().length > 0).some((line) => {
+      const entry = line.slice(3);
+      if (entry === WORKTREE_SESSION_FILE) return false;
+      if (line.startsWith("!!")) {
+        return !DISPOSABLE_IGNORED_ROOTS.has(entry.split("/")[0]);
+      }
+      return true;
+    });
+  } catch {
+    return true;
+  }
+}
+__name(checkoutHasWork, "checkoutHasWork");
+function logWarning(message) {
+  writeStderrLine(`qwen serve: ${message}`);
+}
+__name(logWarning, "logWarning");
+function logWorktreeCleanupPreserve(sessionId, reason) {
+  logWarning(
+    `worktree cleanup preserved checkout action=delete session=${safeLogValue(
+      sessionId
+    )} reason=${safeLogValue(reason)}`
+  );
+}
+__name(logWorktreeCleanupPreserve, "logWorktreeCleanupPreserve");
+async function preclassifyWorktreeCleanup(service, sessionId, runtimeWorkspaceCwd) {
+  let sidecarPath = service.getWorktreeSessionPath(sessionId);
+  let sidecar = await readWorktreeSessionStrict(sidecarPath);
+  if (sidecar.state === "missing") {
+    const archivedPath = service.getWorktreeSessionPathForArchiveState(
+      sessionId,
+      "archived"
+    );
+    if (archivedPath !== sidecarPath) {
+      sidecarPath = archivedPath;
+      sidecar = await readWorktreeSessionStrict(sidecarPath);
+    }
+  }
+  if (sidecar.state === "missing") return void 0;
+  if (sidecar.state === "invalid") {
+    logWorktreeCleanupPreserve(
+      sessionId,
+      `unreadable sidecar (${sidecar.reason})`
+    );
+    return void 0;
+  }
+  const session = sidecar.session;
+  if (session.workspaceCwd === void 0) return void 0;
+  if (session.supersededBy !== void 0) return void 0;
+  if (!path2.isAbsolute(session.workspaceCwd) || !path2.isAbsolute(session.originalCwd)) {
+    logWorktreeCleanupPreserve(
+      sessionId,
+      "sidecar base is not an absolute path"
+    );
+    return void 0;
+  }
+  if (runtimeWorkspaceCwd !== void 0) {
+    if (canonicalPath(session.workspaceCwd) !== canonicalPath(runtimeWorkspaceCwd)) {
+      logWorktreeCleanupPreserve(
+        sessionId,
+        "sidecar belongs to another workspace"
+      );
+      return void 0;
+    }
+    const workspaceRoots = [canonicalPath(runtimeWorkspaceCwd)];
+    try {
+      const repoTop = await new GitWorktreeService(
+        runtimeWorkspaceCwd
+      ).getRepoTopLevel();
+      if (repoTop && canonicalPath(repoTop) !== workspaceRoots[0]) {
+        workspaceRoots.push(canonicalPath(repoTop));
+      }
+    } catch {
+    }
+    if (!workspaceRoots.includes(canonicalPath(session.originalCwd))) {
+      logWorktreeCleanupPreserve(
+        sessionId,
+        "sidecar original cwd is outside the accepted roots"
+      );
+      return void 0;
+    }
+  }
+  return {
+    sessionId,
+    sidecar: session,
+    sidecarPath,
+    lockKey: canonicalPath(session.worktreePath)
+  };
+}
+__name(preclassifyWorktreeCleanup, "preclassifyWorktreeCleanup");
+function acquireWorktreeCleanupLock(plan) {
+  return acquireWorktreeOwnershipOp(plan.lockKey);
+}
+__name(acquireWorktreeCleanupLock, "acquireWorktreeCleanupLock");
+async function worktreeAllowedRoots(workspaceCwd, originalCwd) {
+  const roots = /* @__PURE__ */ new Set();
+  for (const base of [workspaceCwd, originalCwd]) {
+    if (!path2.isAbsolute(base)) continue;
+    roots.add(path2.join(base, ".qwen", "worktrees"));
+    try {
+      const repoTop = await new GitWorktreeService(base).getRepoTopLevel();
+      if (repoTop) {
+        roots.add(path2.join(repoTop, ".qwen", "worktrees"));
+      }
+    } catch {
+    }
+  }
+  return [...roots];
+}
+__name(worktreeAllowedRoots, "worktreeAllowedRoots");
+async function verifyWorktreeCleanupOwnership(plan) {
+  const { sessionId, sidecar } = plan;
+  const locked = await readWorktreeSessionStrict(plan.sidecarPath);
+  if (locked.state !== "valid") {
+    return {
+      ok: false,
+      reason: locked.state === "missing" ? "sidecar disappeared before delete" : `unreadable sidecar (${locked.reason})`
+    };
+  }
+  const current = locked.session;
+  if (current.workspaceCwd === void 0 || current.supersededBy !== void 0 || current.slug !== sidecar.slug || current.worktreePath !== sidecar.worktreePath || current.originalCwd !== sidecar.originalCwd || current.workspaceCwd !== sidecar.workspaceCwd) {
+    return { ok: false, reason: "sidecar changed before delete" };
+  }
+  const marker = await readWorktreeSessionMarkerStrict(plan.lockKey);
+  if (marker.state !== "valid" || marker.sessionId !== sessionId) {
+    return {
+      ok: false,
+      reason: marker.state === "valid" ? "marker names another session" : `marker ${marker.state}`
+    };
+  }
+  const allowedRoots = await worktreeAllowedRoots(
+    current.workspaceCwd,
+    current.originalCwd
+  );
+  const contained = allowedRoots.some((root) => {
+    try {
+      const realRoot = fs.realpathSync(root);
+      return plan.lockKey === realRoot || plan.lockKey.startsWith(realRoot + path2.sep);
+    } catch {
+      return false;
+    }
+  });
+  if (!contained) {
+    return { ok: false, reason: "checkout outside workspace worktree roots" };
+  }
+  const chatsDir = path2.dirname(plan.sidecarPath);
+  const ownFile = path2.basename(plan.sidecarPath);
+  let entries;
+  try {
+    entries = await fsp.readdir(chatsDir);
+  } catch (error) {
+    return {
+      ok: false,
+      reason: `sidecar scan failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+  for (const entry of entries) {
+    if (!entry.endsWith(".worktree.json") || entry === ownFile) continue;
+    const other = await readWorktreeSessionStrict(path2.join(chatsDir, entry));
+    if (other.state === "missing") continue;
+    if (other.state === "invalid") {
+      return { ok: false, reason: `unreadable sibling sidecar ${entry}` };
+    }
+    if (canonicalPath(other.session.worktreePath) === plan.lockKey) {
+      if (other.session.supersededBy === sessionId) continue;
+      return { ok: false, reason: `checkout shared with ${entry}` };
+    }
+  }
+  const removalTarget = canonicalPath(
+    new GitWorktreeService(current.originalCwd).getUserWorktreePath(
+      current.slug
+    )
+  );
+  if (removalTarget !== plan.lockKey) {
+    return {
+      ok: false,
+      reason: "slug does not resolve to the verified checkout"
+    };
+  }
+  plan.sidecar = current;
+  return { ok: true };
+}
+__name(verifyWorktreeCleanupOwnership, "verifyWorktreeCleanupOwnership");
+async function checkoutStillPopulated(worktreePath) {
+  try {
+    return (await fsp.readdir(worktreePath)).length > 0;
+  } catch {
+    return false;
+  }
+}
+__name(checkoutStillPopulated, "checkoutStillPopulated");
+async function executeWorktreeCleanup(plan) {
+  const { sessionId, sidecar } = plan;
+  const marker = await readWorktreeSessionMarkerStrict(plan.lockKey);
+  if (marker.state !== "valid" || marker.sessionId !== sessionId) {
+    logWorktreeCleanupPreserve(sessionId, "marker changed after delete");
+    return;
+  }
+  if (await checkoutHasWork(plan.lockKey)) {
+    logWorktreeCleanupPreserve(sessionId, "checkout has uncommitted work");
+    return;
+  }
+  const result = await new GitWorktreeService(
+    sidecar.originalCwd
+  ).removeUserWorktree(sidecar.slug, { deleteBranch: true });
+  if (!result.success) {
+    const errorText = result.error ?? "unknown error";
+    if (await checkoutStillPopulated(plan.lockKey)) {
+      logWorktreeCleanupPreserve(
+        sessionId,
+        `checkout removal failed: ${errorText}`
+      );
+    } else {
+      logWarning(
+        `worktree cleanup removal failed, checkout may be partially deleted action=delete session=${safeLogValue(
+          sessionId
+        )} reason=${safeLogValue(errorText)}`
+      );
+    }
+    return;
+  }
+  if (result.branchPreserved) {
+    logWarning(
+      `worktree cleanup removed checkout but kept branch action=delete session=${safeLogValue(
+        sessionId
+      )} slug=${safeLogValue(sidecar.slug)} branch=${safeLogValue(
+        sidecar.worktreeBranch
+      )} reason=unmerged commits`
+    );
+  }
+}
+__name(executeWorktreeCleanup, "executeWorktreeCleanup");
+
 // packages/cli/src/serve/server/session-archive.ts
 var DaemonDrainingError = class extends Error {
   static {
@@ -1755,6 +2052,7 @@ async function deleteDaemonSessions(params) {
     coordinator,
     coordinatorLockHeld = false,
     assertCanMutate,
+    runtimeWorkspaceCwd,
     onError
   } = params;
   const uniqueSessionIds = [
@@ -1765,6 +2063,49 @@ async function deleteDaemonSessions(params) {
       coordinator.assertNotTransitioning(sessionId);
     }
   }
+  const runWithWorktreeCleanup = /* @__PURE__ */ __name(async (sessionId, mutateSession) => {
+    const activeSidecarPath = service.getWorktreeSessionPath(sessionId);
+    const archivedSidecarPath = service.getWorktreeSessionPathForArchiveState(
+      sessionId,
+      "archived"
+    );
+    if (!fs2.existsSync(activeSidecarPath) && (archivedSidecarPath === activeSidecarPath || !fs2.existsSync(archivedSidecarPath))) {
+      return coordinator.runExclusiveMany([sessionId], mutateSession);
+    }
+    const cleanupPlan = await preclassifyWorktreeCleanup(
+      service,
+      sessionId,
+      runtimeWorkspaceCwd
+    );
+    if (!cleanupPlan) {
+      return coordinator.runExclusiveMany([sessionId], mutateSession);
+    }
+    const releaseCleanupLock = await acquireWorktreeCleanupLock(cleanupPlan);
+    try {
+      const ownership = await verifyWorktreeCleanupOwnership(cleanupPlan);
+      if (!ownership.ok) {
+        logWorktreeCleanupPreserve(sessionId, ownership.reason);
+      }
+      const result = await coordinator.runExclusiveMany(
+        [sessionId],
+        mutateSession
+      );
+      if (ownership.ok && result.kind === "removed") {
+        try {
+          assertCanMutate?.();
+          await executeWorktreeCleanup(cleanupPlan);
+        } catch (error) {
+          logWorktreeCleanupPreserve(
+            sessionId,
+            `cleanup execution failed: ${errorMessage(error)}`
+          );
+        }
+      }
+      return result;
+    } finally {
+      releaseCleanupLock();
+    }
+  }, "runWithWorktreeCleanup");
   const results = await Promise.all(
     uniqueSessionIds.map(async (sessionId) => {
       try {
@@ -1810,7 +2151,7 @@ async function deleteDaemonSessions(params) {
           try {
             await bridge.closeSession(sessionId);
           } catch (error) {
-            if (isSessionNotFoundError(error)) {
+            if (isSessionNotFoundError(error) && error.code !== "session_closing") {
               return await removePersistedSession();
             }
             onError?.({
@@ -1826,7 +2167,7 @@ async function deleteDaemonSessions(params) {
           }
           return await removePersistedSession();
         }, "mutateSession");
-        return await (coordinatorLockHeld ? mutateSession() : coordinator.runExclusiveMany([sessionId], mutateSession));
+        return await (coordinatorLockHeld ? mutateSession() : runWithWorktreeCleanup(sessionId, mutateSession));
       } catch (error) {
         if (error instanceof DaemonDrainingError) {
           throw error;
@@ -2361,12 +2702,12 @@ __name(unarchiveDaemonSessions, "unarchiveDaemonSessions");
 
 // packages/cli/src/serve/server/aone-mrs.ts
 init_esbuild_shims();
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-var execFileAsync = promisify(execFile);
+import { execFile as execFile2 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+var execFileAsync2 = promisify2(execFile2);
 var a1AvailabilityVerified = false;
 var defaultA1Exec = /* @__PURE__ */ __name(async (args, options) => {
-  const { stdout } = await execFileAsync("a1", [...args], {
+  const { stdout } = await execFileAsync2("a1", [...args], {
     ...options,
     encoding: "utf8",
     windowsHide: true
@@ -2409,7 +2750,7 @@ async function resolveAoneWorkspaceRepo(workspaceCwd, env) {
   if (!gitRoot) return void 0;
   let origin;
   try {
-    ({ stdout: origin } = await execFileAsync(
+    ({ stdout: origin } = await execFileAsync2(
       "git",
       ["remote", "get-url", "origin"],
       {
@@ -2578,6 +2919,7 @@ export {
   parseSessionPageSizeQuery,
   runWithWorkspaceRuntimeStorage,
   createWorkspaceRuntimeSessionService,
+  acquireWorktreeOwnershipOp,
   DaemonDrainingError,
   SessionArchiveCoordinator,
   deleteDaemonSessions,

package/chunks/{chunk-TXAEXF2B.js → chunk-ZU2T5JIS.js}

@@ -75,7 +75,7 @@ import {
   stripToolResultImages,
   toolResultBoundaryArtifact,
   toolResultPartDiagnosticValues
-} from "./chunk-TSLRORQR.js";
+} from "./chunk-PDUMGZ2P.js";
 import {
   hasVerifiableInode,
   openNoFollow
@@ -109,10 +109,10 @@ import {
 import {
   BUILT_IN_OUTPUT_STYLES,
   getBuiltInOutputStyle
-} from "./chunk-OFB36ZBA.js";
+} from "./chunk-3LPJ776W.js";
 import {
   fetchWithPolicy
-} from "./chunk-UKADFFL2.js";
+} from "./chunk-OFVAS4AR.js";
 import {
   COMBINED_PASS_TOLERANCE_FACTOR,
   TOOL_OUTPUT_TRUNCATED_PREFIX,
@@ -121,7 +121,7 @@ import {
   removeMCPStatusChangeListener,
   runSideQuery,
   updateMCPServerStatus
-} from "./chunk-WQBR7LN5.js";
+} from "./chunk-6QV7Z74P.js";
 import {
   getInvocationContext
 } from "./chunk-5ETULJLP.js";
@@ -3293,6 +3293,7 @@ function specToModelConfig(spec, prefix, baseUrl, envKey) {
     id: spec.id,
     name: prefix ? `[${prefix}] ${spec.id}` : spec.id,
     ...spec.description ? { description: spec.description } : {},
+    ...spec.capabilities ? { capabilities: spec.capabilities } : {},
     baseUrl,
     envKey,
     ...spec.supportsImageGeneration ? { supportsImageGeneration: true } : {},
@@ -3327,11 +3328,16 @@ function buildModelConfigs(config, inputs) {
       (spec) => specToModelConfig(spec, prefix, inputs.baseUrl, envKey)
     );
   } else if (config.models && config.modelsEditable) {
-    const specMap = new Map(config.models.map((s) => [s.id, s]));
+    const specMap = new Map(config.models.map((s) => [s.id.toLowerCase(), s]));
     models = inputs.modelIds.map((id) => {
-      const spec = specMap.get(id);
+      const spec = specMap.get(id.toLowerCase());
       if (spec) {
-        return specToModelConfig(spec, prefix, inputs.baseUrl, envKey);
+        return specToModelConfig(
+          { ...spec, id },
+          prefix,
+          inputs.baseUrl,
+          envKey
+        );
       }
       const genConfig = buildAdvancedGenerationConfig(inputs.advancedConfig);
       return {
@@ -3841,7 +3847,14 @@ var deepseekProvider = {
     {
       id: "deepseek-v4-pro",
       contextWindowSize: 1e6,
-      enableThinking: true
+      capabilities: {
+        reasoning: {
+          thinking: true,
+          efforts: ["high", "max"],
+          defaultEffort: "high",
+          disableField: "thinking"
+        }
+      }
     },
     { id: "deepseek-v4-flash", contextWindowSize: 1e6 }
   ],

package/chunks/{config-utils-F4CFJ4MW.js → config-utils-KTDSQ4MU.js}

@@ -6,42 +6,42 @@ import {
   parseChannelWebhookConfig,
   parseChannelWebhookConfigLenient,
   resolveEnvVars
-} from "./chunk-BNWIX6BM.js";
-import "./chunk-RGAQDQ3Z.js";
-import "./chunk-RH344FKI.js";
+} from "./chunk-UXDVUFKU.js";
+import "./chunk-UHUT4IDM.js";
+import "./chunk-3BTHHXXE.js";
 import {
   findCliEntryPath
 } from "./chunk-V6WHFGST.js";
-import "./chunk-65GHQ4FX.js";
+import "./chunk-XVTCSVBK.js";
 import "./chunk-IW6RQPQB.js";
-import "./chunk-TXAEXF2B.js";
+import "./chunk-ZU2T5JIS.js";
 import "./chunk-GELRJXE2.js";
 import "./chunk-32CM56LO.js";
-import "./chunk-C7M445SS.js";
+import "./chunk-WJDXKQIO.js";
 import "./chunk-2EKVPSIJ.js";
 import "./chunk-LJZSMWOH.js";
-import "./chunk-E4VX6LXB.js";
-import "./chunk-RSU3I6UL.js";
+import "./chunk-YZTGGCEE.js";
+import "./chunk-6SADVYQQ.js";
 import "./chunk-DJXSOEFB.js";
-import "./chunk-KTLT7VCX.js";
+import "./chunk-25CBAK3H.js";
 import "./chunk-J3VZF2AL.js";
 import "./chunk-OWCFKIFQ.js";
 import "./chunk-ZPJWUGCS.js";
 import "./chunk-5Z4FCEPY.js";
 import "./chunk-BUQN5LTI.js";
-import "./chunk-VU7O7CGQ.js";
-import "./chunk-SD7Y2PMC.js";
+import "./chunk-XDNFODER.js";
+import "./chunk-YAC7H4K3.js";
 import "./chunk-VNOVK4I7.js";
-import "./chunk-TSLRORQR.js";
+import "./chunk-PDUMGZ2P.js";
 import "./chunk-GOFAQQZA.js";
-import "./chunk-3K65MUKD.js";
+import "./chunk-65I7S4Z3.js";
 import "./chunk-6HUXPLB5.js";
 import "./chunk-TWPJO254.js";
 import "./chunk-CQ35AJ4Z.js";
 import "./chunk-YHDGABDC.js";
 import "./chunk-LYT2OU7D.js";
 import "./chunk-B54PFQS5.js";
-import "./chunk-ERMAXPXA.js";
+import "./chunk-HIXUUCGY.js";
 import "./chunk-6PVPNMXU.js";
 import "./chunk-565U2ANU.js";
 import "./chunk-FDOGGKAA.js";
@@ -59,26 +59,26 @@ import "./chunk-BF3RUIVP.js";
 import "./chunk-JX6XHPTX.js";
 import "./chunk-CLKE4IY3.js";
 import "./chunk-ZSTCM3MX.js";
-import "./chunk-NXWYCSPL.js";
+import "./chunk-SOA4HKRJ.js";
 import "./chunk-MLXTMF7H.js";
-import "./chunk-OFB36ZBA.js";
+import "./chunk-3LPJ776W.js";
 import "./chunk-3CZ2BQV6.js";
 import "./chunk-PQEISIKS.js";
-import "./chunk-3K456UJF.js";
+import "./chunk-VF6D6EGV.js";
 import "./chunk-H3Q3RSKZ.js";
 import "./chunk-S6LOFUVP.js";
 import "./chunk-NAVJD2PQ.js";
-import "./chunk-UKADFFL2.js";
-import "./chunk-EJNYBDYC.js";
+import "./chunk-OFVAS4AR.js";
+import "./chunk-HNLMYDQE.js";
 import "./chunk-QHMLYMMS.js";
 import "./chunk-CFKIH3D3.js";
-import "./chunk-2LD5U7Q3.js";
+import "./chunk-6YEOCHSE.js";
 import "./chunk-DJ2GSRLV.js";
-import "./chunk-W4LL5RZO.js";
-import "./chunk-3UMWOKJC.js";
+import "./chunk-4ALNJDHL.js";
+import "./chunk-NOO4QFXM.js";
 import "./chunk-KFFCDLKV.js";
 import "./chunk-7OCIQNKX.js";
-import "./chunk-WQBR7LN5.js";
+import "./chunk-6QV7Z74P.js";
 import "./chunk-5ETULJLP.js";
 import "./chunk-XBVNNDPK.js";
 import "./chunk-VGC4I5JJ.js";
@@ -88,7 +88,7 @@ import "./chunk-HD7O6WLV.js";
 import "./chunk-WZAD4ZNJ.js";
 import "./chunk-FPGTNKCP.js";
 import "./chunk-TIGXX4PA.js";
-import "./chunk-PLUAIHZO.js";
+import "./chunk-N7YQEKGX.js";
 import "./chunk-XFFRI3WM.js";
 import "./chunk-4HOEU2OR.js";
 import "./chunk-HHJLM3WQ.js";