@qwen-code/qwen-code 0.21.13 → 0.21.14

package/chunks/{daemon-2KTG7ZBN.js → daemon-XH76IXOC.js}

@@ -2198,6 +2198,22 @@ var DaemonClient = class {
       "GET /workspace/sessions"
     );
   }
+  /**
+   * Read the memory-only live-state snapshot for a workspace via
+   * `GET /workspaces/:workspace/sessions/live-state`: the complete set of
+   * live sessions with volatile state plus the in-memory catalog version
+   * equality token. Always uses native REST transport (never the pluggable
+   * ACP transport).
+   *
+   * This method deliberately does not pre-flight
+   * `requireCapability('workspace_session_live_state')` — a capability
+   * probe on every poll would double request volume. Consumers preflight
+   * the capability once from their already-loaded capabilities and fall
+   * back to the full session catalog when it is absent.
+   */
+  getWorkspaceSessionLiveState(workspaceCwd, opts = {}) {
+    return this.workspaceByCwd(workspaceCwd).getSessionLiveState(opts);
+  }
   async listSessionGroups(workspaceCwd) {
     return await this.jsonRequest(
       `/workspace/${urlEncode(workspaceCwd)}/session-groups`,
@@ -2644,11 +2660,76 @@ var DaemonClient = class {
     if (!res.ok) throw await this.failOnError(res, "POST /session/:id/btw");
     return await res.json();
   }
+  async uploadSessionMedia(sessionId, data, mimeType, opts) {
+    return await this.fetchWithTimeout(
+      `${this.baseUrl}/session/${urlEncode(sessionId)}/media`,
+      {
+        method: "POST",
+        headers: this.headers({ "Content-Type": mimeType }, opts?.clientId),
+        body: data,
+        signal: opts?.signal
+      },
+      async (res) => {
+        if (!res.ok) {
+          throw await this.failOnError(res, "POST /session/:id/media");
+        }
+        return await res.json();
+      }
+    );
+  }
+  async readSessionMedia(sessionId, mediaId, opts) {
+    return await this.fetchWithTimeout(
+      `${this.baseUrl}/session/${urlEncode(sessionId)}/media/${urlEncode(mediaId)}`,
+      {
+        method: "GET",
+        headers: this.headers({}, opts?.clientId),
+        signal: opts?.signal
+      },
+      async (res) => {
+        if (!res.ok) {
+          throw await this.failOnError(res, "GET /session/:id/media/:mediaId");
+        }
+        const bytes = new Uint8Array(await res.arrayBuffer());
+        let binary = "";
+        for (let offset = 0; offset < bytes.length; offset += 32768) {
+          binary += String.fromCharCode(
+            ...bytes.subarray(offset, offset + 32768)
+          );
+        }
+        return {
+          data: btoa(binary),
+          mimeType: res.headers.get("content-type") ?? "application/octet-stream"
+        };
+      }
+    );
+  }
+  async removeSessionMedia(sessionId, mediaId, opts) {
+    return await this.fetchWithTimeout(
+      `${this.baseUrl}/session/${urlEncode(sessionId)}/media/${urlEncode(mediaId)}`,
+      {
+        method: "DELETE",
+        headers: this.headers({}, opts?.clientId),
+        signal: opts?.signal
+      },
+      async (res) => {
+        if (!res.ok) {
+          throw await this.failOnError(
+            res,
+            "DELETE /session/:id/media/:mediaId"
+          );
+        }
+        return (await res.json()).removed === true;
+      }
+    );
+  }
   /**
    * Queue a user message typed while the session's turn is still running. The
    * ACP child drains it between tool batches so the model sees it before the
    * turn ends. Every accepted request is daemon-owned; a caller-supplied id
-   * makes ambiguous retries idempotent.
+   * makes ambiguous retries idempotent. `opts.content` carries media content
+   * image blocks alongside the text — pre-flight the
+   * `session_media` capability; older daemons ignore the
+   * field and drop the media.
    */
   async enqueueMidTurnMessage(sessionId, message, opts) {
     return await this.fetchWithTimeout(
@@ -2659,7 +2740,11 @@ var DaemonClient = class {
           { "Content-Type": "application/json" },
           opts?.clientId
         ),
-        body: JSON.stringify({ message, messageId: opts?.messageId }),
+        body: JSON.stringify({
+          message,
+          messageId: opts?.messageId,
+          ...opts?.content && opts.content.length > 0 ? { content: opts.content } : {}
+        }),
         signal: opts?.signal
       },
       async (res) => {
@@ -4595,6 +4680,26 @@ var WorkspaceDaemonClient = class {
   getWorkspaceSessionInfo() {
     return this.get("/session-info", "GET /workspaces/:workspace/session-info");
   }
+  /**
+   * Read the memory-only live-state snapshot for this workspace: the
+   * complete set of live sessions with volatile state plus the in-memory
+   * catalog version equality token. Always uses native REST transport
+   * (never the pluggable ACP transport).
+   *
+   * This method deliberately does not pre-flight
+   * `requireCapability('workspace_session_live_state')` — a capability
+   * probe on every poll would double request volume. Consumers preflight
+   * the capability once from their already-loaded capabilities and fall
+   * back to the full session catalog when it is absent.
+   */
+  getSessionLiveState(opts = {}) {
+    return this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      "/sessions/live-state",
+      "GET /workspaces/:workspace/sessions/live-state",
+      { clientId: opts.clientId, timeoutMs: opts.timeoutMs, mode: "rest" }
+    );
+  }
   /**
    * Read one page from an active persisted session transcript in this
    * workspace.
@@ -4625,6 +4730,14 @@ var WorkspaceDaemonClient = class {
       opts
     );
   }
+  updateSessionMetadata(sessionId, metadata, clientId) {
+    return this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      `/session/${urlEncode(sessionId)}/metadata`,
+      "PATCH /workspaces/:workspace/session/:id/metadata",
+      { method: "PATCH", body: metadata, clientId, mode: "rest" }
+    );
+  }
   listSessionGroups() {
     return this.get(
       "/session-groups",
@@ -4983,6 +5096,14 @@ __name(isNonBlockingAccepted, "isNonBlockingAccepted");
 
 // packages/sdk-typescript/src/daemon/DaemonSessionClient.ts
 init_esbuild_shims();
+function isSessionMediaReference(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  return record["type"] === "image" && typeof record["mediaId"] === "string" && record["mediaId"].length > 0 && typeof record["mimeType"] === "string" && record["mimeType"].startsWith(`${record["type"]}/`) && typeof record["size"] === "number" && Number.isSafeInteger(record["size"]) && record["size"] > 0;
+}
+__name(isSessionMediaReference, "isSessionMediaReference");
+var MAX_MEDIA_CACHE_BYTES = 32 * 1024 * 1024;
+var MAX_MEDIA_CACHE_ENTRIES = 128;
 var DaemonSessionClient = class _DaemonSessionClient {
   static {
     __name(this, "DaemonSessionClient");
@@ -5024,6 +5145,8 @@ var DaemonSessionClient = class _DaemonSessionClient {
   reattaching;
   cancelling;
   promptLimit;
+  mediaCache = /* @__PURE__ */ new Map();
+  mediaCacheBytes = 0;
   _pendingPrompts = /* @__PURE__ */ new Map();
   constructor(opts) {
     this.client = opts.client;
@@ -5083,7 +5206,7 @@ var DaemonSessionClient = class _DaemonSessionClient {
       eventEpoch,
       ...session
     } = restored;
-    return new _DaemonSessionClient({
+    const result = new _DaemonSessionClient({
       client,
       session,
       hasActivePrompt,
@@ -5101,6 +5224,8 @@ var DaemonSessionClient = class _DaemonSessionClient {
       historyAnchorRecordId,
       replayDegraded
     });
+    await result.hydrateReplaySnapshot();
+    return result;
   }
   /**
    * Resumes an existing daemon session without requesting history replay.
@@ -5233,6 +5358,29 @@ var DaemonSessionClient = class _DaemonSessionClient {
     }
     return accepted;
   }
+  async uploadMedia(data, mimeType, signal) {
+    return await this.withClientIdSelfHeal(
+      () => this.client.uploadSessionMedia(this.sessionId, data, mimeType, {
+        ...signal ? { signal } : {},
+        ...this.clientId ? { clientId: this.clientId } : {}
+      })
+    );
+  }
+  async removeMedia(mediaId) {
+    const removed = await this.withClientIdSelfHeal(
+      () => this.client.removeSessionMedia(
+        this.sessionId,
+        mediaId,
+        this.clientId ? { clientId: this.clientId } : void 0
+      )
+    );
+    if (removed) {
+      const cached = this.mediaCache.get(mediaId);
+      this.mediaCache.delete(mediaId);
+      this.mediaCacheBytes -= cached?.size ?? 0;
+    }
+    return removed;
+  }
   /**
    * Run a prompt-admission call, recovering from a stale `clientId`.
    *
@@ -5377,6 +5525,7 @@ var DaemonSessionClient = class _DaemonSessionClient {
     return await this.client.enqueueMidTurnMessage(this.sessionId, message, {
       ...opts?.signal ? { signal: opts.signal } : {},
       ...opts?.messageId ? { messageId: opts.messageId } : {},
+      ...opts?.content && opts.content.length > 0 ? { content: opts.content } : {},
       ...this.clientId ? { clientId: this.clientId } : {}
     });
   }
@@ -5393,15 +5542,44 @@ var DaemonSessionClient = class _DaemonSessionClient {
    * callers preserve their current state.
    */
   async getMidTurnMessages(opts) {
-    return await this.client.getMidTurnMessages(this.sessionId, {
+    const result = await this.client.getMidTurnMessages(this.sessionId, {
       ...opts?.signal ? { signal: opts.signal } : {},
       ...this.clientId ? { clientId: this.clientId } : {}
     });
+    return {
+      ...result,
+      messages: await Promise.all(
+        result.messages.map(async (message) => ({
+          ...message,
+          ...message.content ? { content: await this.hydrateContent(message.content) } : {}
+        }))
+      )
+    };
   }
   async getPendingPrompts() {
-    return await this.client.getPendingPrompts(this.sessionId, {
+    const result = await this.client.getPendingPrompts(this.sessionId, {
       ...this.clientId ? { clientId: this.clientId } : {}
     });
+    return {
+      pendingPrompts: await Promise.all(
+        result.pendingPrompts.map(async (prompt) => ({
+          ...prompt,
+          ...prompt.content ? { content: await this.hydrateContent(prompt.content) } : {}
+        }))
+      )
+    };
+  }
+  async getTranscriptPage(opts = {}) {
+    const page = await this.client.getSessionTranscriptPage(this.sessionId, {
+      ...opts,
+      clientId: opts.clientId ?? this.clientId
+    });
+    return {
+      ...page,
+      events: await Promise.all(
+        page.events.map(async (event) => await this.hydrateEvent(event))
+      )
+    };
   }
   async removePendingPrompt(promptId) {
     return await this.client.removePendingPrompt(this.sessionId, promptId, {
@@ -5581,8 +5759,9 @@ var DaemonSessionClient = class _DaemonSessionClient {
           callerOnEpoch?.(learned);
         }, "onEpoch")
       })) {
-        this._dispatchTurnEvent(event);
-        yield event;
+        const hydratedEvent = await this.hydrateEvent(event);
+        this._dispatchTurnEvent(hydratedEvent);
+        yield hydratedEvent;
         if (event.id !== void 0) {
           this.lastSeenEventId = Math.max(
             this.lastSeenEventId ?? 0,
@@ -5595,6 +5774,107 @@ var DaemonSessionClient = class _DaemonSessionClient {
       release();
     }
   }
+  async hydrateReplaySnapshot() {
+    this.replaySnapshot.compactedReplay = await Promise.all(
+      this.replaySnapshot.compactedReplay.map(
+        async (event) => await this.hydrateEvent(event)
+      )
+    );
+    this.replaySnapshot.liveJournal = await Promise.all(
+      this.replaySnapshot.liveJournal.map(
+        async (event) => await this.hydrateEvent(event)
+      )
+    );
+  }
+  async hydrateEvent(event) {
+    if (!event.data || typeof event.data !== "object") return event;
+    const data = event.data;
+    if (event.type === "session_update") {
+      const update = data["update"];
+      if (update && typeof update === "object" && !Array.isArray(update)) {
+        const content2 = update["content"];
+        const hydrated2 = await this.hydrateBlock(content2);
+        if (hydrated2 === content2) return event;
+        return {
+          ...event,
+          data: { ...data, update: { ...update, content: hydrated2 } }
+        };
+      }
+      const content = data["content"];
+      const hydrated = await this.hydrateBlock(content);
+      if (hydrated === content) return event;
+      return { ...event, data: { ...data, content: hydrated } };
+    }
+    if (event.type !== "mid_turn_message_injected") return event;
+    const items = data["items"];
+    if (!Array.isArray(items)) return event;
+    return {
+      ...event,
+      data: {
+        ...data,
+        items: await Promise.all(
+          items.map(async (item) => {
+            if (!item || typeof item !== "object" || Array.isArray(item)) {
+              return item;
+            }
+            const record = item;
+            return Array.isArray(record["content"]) ? {
+              ...record,
+              content: await this.hydrateContent(record["content"])
+            } : item;
+          })
+        )
+      }
+    };
+  }
+  async hydrateContent(content) {
+    return await Promise.all(
+      content.map(async (block) => await this.hydrateBlock(block))
+    );
+  }
+  async hydrateBlock(block) {
+    if (!isSessionMediaReference(block)) {
+      return block;
+    }
+    let cached = this.mediaCache.get(block.mediaId);
+    if (cached) {
+      this.mediaCache.delete(block.mediaId);
+      this.mediaCache.set(block.mediaId, cached);
+    } else {
+      const pending = this.withClientIdSelfHeal(
+        () => this.client.readSessionMedia(this.sessionId, block.mediaId, {
+          ...this.clientId ? { clientId: this.clientId } : {}
+        })
+      );
+      cached = { pending, size: block.size };
+      this.mediaCache.set(block.mediaId, cached);
+      this.mediaCacheBytes += block.size;
+      while (this.mediaCache.size > MAX_MEDIA_CACHE_ENTRIES || this.mediaCacheBytes > MAX_MEDIA_CACHE_BYTES) {
+        const oldestId = this.mediaCache.keys().next().value;
+        if (oldestId === void 0) break;
+        const evicted = this.mediaCache.get(oldestId);
+        this.mediaCache.delete(oldestId);
+        this.mediaCacheBytes -= evicted?.size ?? 0;
+      }
+      void pending.catch(() => {
+        if (this.mediaCache.get(block.mediaId)?.pending !== pending) return;
+        this.mediaCache.delete(block.mediaId);
+        this.mediaCacheBytes -= block.size;
+      });
+    }
+    try {
+      const media = await cached.pending;
+      return { type: block.type, data: media.data, mimeType: media.mimeType };
+    } catch (err) {
+      if (err instanceof DaemonHttpError && (err.status === 404 || err.status === 410)) {
+        return {
+          type: "text",
+          text: "[Attached media is no longer available]"
+        };
+      }
+      return block;
+    }
+  }
   _dispatchTurnEvent(event) {
     if (event.type !== "turn_complete" && event.type !== "turn_error") return;
     const promptId = event.data?.promptId;
@@ -5931,7 +6211,7 @@ function asKnownDaemonEvent(event) {
     case "tool_toggled":
       return isToolToggledData(event.data) ? event : void 0;
     case "settings_changed":
-      return event.data != null && typeof event.data === "object" ? event : void 0;
+      return isSettingsChangedData(event.data) ? event : void 0;
     case "trust_change_requested":
       return isTrustChangeRequestedData(event.data) ? event : void 0;
     case "workspace_initialized":
@@ -6633,6 +6913,19 @@ function isToolToggledData(value) {
   return isRecord(value) && isNonEmptyString(value["toolName"]) && typeof value["enabled"] === "boolean";
 }
 __name(isToolToggledData, "isToolToggledData");
+function isDaemonSkillToggleMutation(value) {
+  if (!isRecord(value)) return false;
+  const activation = value["activation"];
+  const skills = value["skills"];
+  return isNonEmptyString(value["id"]) && value["kind"] === "skill_toggle" && Array.isArray(skills) && skills.length > 0 && skills.every(
+    (skill) => isRecord(skill) && isNonEmptyString(skill["name"]) && typeof skill["enabled"] === "boolean"
+  ) && (activation === "applied" || activation === "deferred" || activation === "partial") && isFiniteNumber(value["sessionsRefreshed"]) && isFiniteNumber(value["sessionsFailed"]);
+}
+__name(isDaemonSkillToggleMutation, "isDaemonSkillToggleMutation");
+function isSettingsChangedData(value) {
+  return isRecord(value) && isNonEmptyString(value["key"]) && (value["scope"] === void 0 || typeof value["scope"] === "string") && (value["mutation"] === void 0 || isDaemonSkillToggleMutation(value["mutation"]));
+}
+__name(isSettingsChangedData, "isSettingsChangedData");
 function isTrustChangeRequestedData(value) {
   if (!isRecord(value)) return false;
   const desiredState = value["desiredState"];
@@ -7077,6 +7370,7 @@ var MCP_RESTART_REFUSED_REASONS2 = /* @__PURE__ */ new Set([
 var MALFORMED_MEMORY_CHANGED = "malformed memory_changed payload";
 var MAX_DETAILS_LENGTH = 4096;
 var SESSION_RECORDING_DEGRADED_MESSAGE = "Session recording stopped after a write failure. New messages for the affected session will not be saved. Check disk space and permissions, then start a new session to resume recording.";
+var MEDIA_UNAVAILABLE_TEXT = "[Attached media is no longer available]";
 function normalizeDaemonEvent(event, opts = {}) {
   const base = createBase(event, opts);
   switch (event.type) {
@@ -7453,21 +7747,37 @@ function normalizeMidTurnMessageInjected(event, base) {
   if (!isRecord2(event.data)) {
     return fallbackDebug(event, base, "malformed mid_turn_message_injected");
   }
-  const messages = Array.isArray(event.data["messages"]) ? event.data["messages"].filter(
-    (message) => typeof message === "string" && message.length > 0
-  ) : [];
-  if (messages.length === 0) {
+  const data = event.data;
+  const rawMessages = data["messages"];
+  const messages = Array.isArray(rawMessages) && rawMessages.every(
+    (message) => typeof message === "string"
+  ) ? rawMessages : [];
+  const items = data["items"];
+  const hasRenderableItemContent = Array.isArray(items) && items.some(
+    (item) => isRecord2(item) && Array.isArray(item["content"]) && item["content"].some(
+      (block) => isRecord2(block) && (block["type"] === "image" || block["type"] === "text" && typeof block["text"] === "string" && block["text"].length > 0)
+    )
+  );
+  if (messages.length === 0 || !messages.some(Boolean) && !hasRenderableItemContent) {
     return fallbackDebug(event, base, "malformed mid_turn_message_injected");
   }
-  return [
-    {
+  const messageIds = Array.isArray(data["messageIds"]) ? data["messageIds"] : [];
+  return messages.map((text, index) => {
+    const item = Array.isArray(items) ? items[index] : void 0;
+    const messageId = messageIds[index];
+    return {
       ...base,
       type: "status",
-      text: `Inserted message: ${messages.join("\n")}`,
+      text,
       source: "mid_turn_message_injected",
-      data: event.data
-    }
-  ];
+      data: {
+        ...data,
+        messages: [text],
+        ...Array.isArray(items) ? { items: item !== void 0 ? [item] : [] } : {},
+        ...typeof messageId === "string" ? { messageIds: [messageId] } : Array.isArray(data["messageIds"]) ? { messageIds: [] } : {}
+      }
+    };
+  });
 }
 __name(normalizeMidTurnMessageInjected, "normalizeMidTurnMessageInjected");
 function createBase(event, opts) {
@@ -7540,6 +7850,10 @@ function parseTimestamp(value) {
   return Number.isFinite(parsed) ? parsed : void 0;
 }
 __name(parseTimestamp, "parseTimestamp");
+function isMediaReferenceContent(value) {
+  return isRecord2(value) && value["type"] === "image" && typeof value["mediaId"] === "string" && value["mediaId"].length > 0 && value["data"] === void 0 && value["url"] === void 0 && value["source"] === void 0;
+}
+__name(isMediaReferenceContent, "isMediaReferenceContent");
 function normalizeSessionUpdate(event, base, opts) {
   const update = getSessionUpdatePayload(event.data);
   if (!update) {
@@ -7574,7 +7888,15 @@ function normalizeSessionUpdate(event, base, opts) {
             else if (prefix.startsWith("UklGR")) mimeType = "image/webp";
           }
           if (data) {
-            return [{ ...base, type: "user.image.delta", data, mimeType }];
+            return [
+              {
+                ...base,
+                type: "user.image.delta",
+                data,
+                mimeType,
+                ...meta ? { meta } : {}
+              }
+            ];
           }
           return [];
         }
@@ -7590,6 +7912,16 @@ function normalizeSessionUpdate(event, base, opts) {
         }
         return [];
       }
+      if (isMediaReferenceContent(content)) {
+        return [
+          {
+            ...base,
+            type: "user.text.delta",
+            text: MEDIA_UNAVAILABLE_TEXT,
+            ...meta ? { meta } : {}
+          }
+        ];
+      }
       const text = getTextContent(content);
       return text ? [
         {
@@ -8128,13 +8460,15 @@ function normalizeSettingsChanged(event, base) {
   if (!key) {
     return fallbackDebug(event, base, "malformed settings_changed payload");
   }
+  const mutation = isSettingsChangedData(event.data) && event.data.mutation;
   return [
     {
       ...base,
       type: "workspace.settings.changed",
       key,
       scope: scope ?? "workspace",
-      value: isRecord2(event.data) ? event.data["value"] : void 0
+      value: isRecord2(event.data) ? event.data["value"] : void 0,
+      ...mutation ? { mutation } : {}
     }
   ];
 }
@@ -8989,7 +9323,7 @@ function applyDaemonTranscriptEvent(next, event) {
           "",
           event.eventId,
           event.serverTimestamp,
-          void 0,
+          event.meta,
           event.sourceRecordIds,
           event.promptId
         );
@@ -8999,6 +9333,7 @@ function applyDaemonTranscriptEvent(next, event) {
       } else {
         const block = getWritableBlockById(next, next.activeUserBlockId);
         if (block && block.kind === "user") {
+          if (event.meta) block.meta = { ...block.meta, ...event.meta };
           block.images = [
             ...block.images ?? [],
             { data: event.data, mimeType: event.mimeType }

package/chunks/{daemon-git-worktree-guard-DXYIMWFT.js → daemon-git-worktree-guard-6P27GKSU.js}

@@ -8,34 +8,34 @@ import {
   GitWorktreeService,
   require_shell_quote,
   splitCommands
-} from "./chunk-4S5337WV.js";
+} from "./chunk-OFTPCOGR.js";
 import "./chunk-GOFAQQZA.js";
 import "./chunk-5M6IDOMF.js";
 import "./chunk-TWPJO254.js";
 import "./chunk-CQ35AJ4Z.js";
-import "./chunk-DGZEMW5R.js";
-import "./chunk-WSH6GRKG.js";
-import "./chunk-CKSJECTU.js";
-import "./chunk-OVZPVYZB.js";
+import "./chunk-FS5NGKWC.js";
+import "./chunk-SLILKYV2.js";
+import "./chunk-NVRMCWTP.js";
+import "./chunk-AKBOLMUF.js";
 import "./chunk-6PVPNMXU.js";
-import "./chunk-5EYKMUUY.js";
+import "./chunk-544KT7X4.js";
 import "./chunk-IRH27ZC2.js";
 import "./chunk-QHWCP53L.js";
-import "./chunk-Y3YCSWG5.js";
-import "./chunk-UPDOZBWO.js";
+import "./chunk-OBJYN4MX.js";
+import "./chunk-2C6HJMG3.js";
 import "./chunk-O6GEWCJA.js";
 import "./chunk-T26EAKDL.js";
 import "./chunk-ZPJWUGCS.js";
 import "./chunk-CPBF7KYF.js";
 import "./chunk-RWDNJBWN.js";
-import "./chunk-25EYDK42.js";
+import "./chunk-WPVUOVYX.js";
 import "./chunk-MIPFDQAF.js";
 import "./chunk-MLXTMF7H.js";
 import "./chunk-KV27IEHM.js";
 import "./chunk-E3DYKPYZ.js";
-import "./chunk-OMLJNPBE.js";
-import "./chunk-OXCMMLED.js";
-import "./chunk-TIGA2IVL.js";
+import "./chunk-4ZMS3JCR.js";
+import "./chunk-DGJ7O55J.js";
+import "./chunk-OO4FKHLO.js";
 import "./chunk-SAH4BD2J.js";
 import "./chunk-XLLKYULU.js";
 import "./chunk-PT4I7NBA.js";
@@ -45,7 +45,7 @@ import "./chunk-SG7ZP5PG.js";
 import "./chunk-K623ENWT.js";
 import "./chunk-AQ37AY7B.js";
 import "./chunk-KBXKR5R2.js";
-import "./chunk-GMIEIY3Y.js";
+import "./chunk-I3N2Z25H.js";
 import "./chunk-NAVJD2PQ.js";
 import "./chunk-ROIYNTHJ.js";
 import "./chunk-2B2BF7P7.js";
@@ -53,30 +53,31 @@ import "./chunk-P3QQPMQA.js";
 import "./chunk-YZHRN3CF.js";
 import "./chunk-FAAUPSY2.js";
 import "./chunk-KM73TBQ4.js";
-import "./chunk-MPHPFVKK.js";
 import "./chunk-AXMWHKXA.js";
 import "./chunk-GLCZKT5V.js";
 import "./chunk-DJ2GSRLV.js";
 import "./chunk-QFJ5JHQR.js";
-import {
-  isWithinRoot
-} from "./chunk-RVOJ2FBP.js";
+import "./chunk-KC4WMLZO.js";
 import "./chunk-YRLW2MSX.js";
 import "./chunk-VGC4I5JJ.js";
+import {
+  isWithinRoot
+} from "./chunk-3PWCMXIR.js";
 import "./chunk-CHHABXPE.js";
 import "./chunk-MA2HEDVP.js";
 import "./chunk-XUJNK7Y6.js";
 import "./chunk-6HY6IF3Z.js";
-import "./chunk-4PKCUT7F.js";
+import "./chunk-2A6VQJYK.js";
 import "./chunk-F6WFNA7U.js";
-import "./chunk-46UV252V.js";
+import "./chunk-WZAD4ZNJ.js";
 import "./chunk-FPGTNKCP.js";
+import "./chunk-YHC2EYYG.js";
 import "./chunk-CPHEPGAO.js";
-import "./chunk-P7MPQI75.js";
-import "./chunk-FDGGZIYW.js";
-import "./chunk-EL5SXY3T.js";
+import "./chunk-DVR7XKO5.js";
+import "./chunk-YECDICIO.js";
+import "./chunk-XT4RKHVE.js";
 import "./chunk-HHJLM3WQ.js";
-import "./chunk-K5IDV3PC.js";
+import "./chunk-D34RDOLP.js";
 import {
   realpathNearestExistingAsync
 } from "./chunk-BUQDLC2G.js";