@qwen-code/qwen-code 0.23.0 → 0.23.1-preview.1

package/chunks/{chunk-4UANMABT.js → chunk-HFTB354P.js}

@@ -3,17 +3,17 @@
 import {
   listLiveSessions,
   readOwnSessionRecord
-} from "./chunk-CVX63TFJ.js";
+} from "./chunk-B44JBZBB.js";
 import {
   LEADER_NAME,
   sanitizeName
-} from "./chunk-373DQUVA.js";
+} from "./chunk-BF3RUIVP.js";
 import {
   APPROVAL_MODES
 } from "./chunk-JX6XHPTX.js";
 import {
   createDebugLogger
-} from "./chunk-EAHOJF6V.js";
+} from "./chunk-ZAFYHRVY.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -132,7 +132,7 @@ function parsePeerFrame(line) {
   if (parsed["type"] === "control") {
     if (parsed["action"] !== "delivery_status") return null;
     const status = parsed["status"];
-    if (status !== "held" && status !== "denied" && status !== "expired" && status !== "delivered" && status !== "misaddressed") {
+    if (status !== "held" && status !== "denied" && status !== "refused" && status !== "expired" && status !== "delivered" && status !== "misaddressed") {
       return null;
     }
     const origMsgId = parsed["origMsgId"];
@@ -177,6 +177,8 @@ function describeDeliveryStatus(status) {
       return "Your message is held for the recipient user to review before it reaches their Qwen Code session.";
     case "denied":
       return "The recipient declined your message; it was not delivered.";
+    case "refused":
+      return "The recipient session does not accept messages from other sessions, so nobody saw this one. Don't re-send it; reach that session's user another way.";
     case "expired":
       return "Your held message expired without a decision and was not delivered.";
     case "delivered":
@@ -231,24 +233,24 @@ import * as os from "node:os";
 import * as path from "node:path";
 var MAX_SOCKET_PATH_BYTES = 103;
 var SOCKET_DIR_NAME = "qwen-socks";
-function resolvePeerSocketPath(pid = process.pid) {
+function resolvePeerSocketCandidates(pid = process.pid) {
+  const candidates = [];
   const runtimeDir = process.env["XDG_RUNTIME_DIR"];
   if (runtimeDir) {
-    const preferred = path.join(runtimeDir, SOCKET_DIR_NAME, `${pid}.sock`);
-    if (Buffer.byteLength(preferred) <= MAX_SOCKET_PATH_BYTES) {
-      return preferred;
-    }
+    candidates.push(path.join(runtimeDir, SOCKET_DIR_NAME, `${pid}.sock`));
   }
   const nonce = randomBytes(8).toString("hex");
-  const fallback = path.join(
-    os.tmpdir(),
-    `${SOCKET_DIR_NAME}-${nonce}`,
-    `${pid}.sock`
+  candidates.push(
+    path.join(os.tmpdir(), `${SOCKET_DIR_NAME}-${nonce}`, `${pid}.sock`)
+  );
+  candidates.push(
+    path.join("/tmp", `${SOCKET_DIR_NAME}-${nonce}`, `${pid}.sock`)
+  );
+  return candidates.filter(
+    (candidate, index) => Buffer.byteLength(candidate) <= MAX_SOCKET_PATH_BYTES && candidates.indexOf(candidate) === index
   );
-  if (Buffer.byteLength(fallback) <= MAX_SOCKET_PATH_BYTES) return fallback;
-  return path.join("/tmp", `${SOCKET_DIR_NAME}-${nonce}`, `${pid}.sock`);
 }
-__name(resolvePeerSocketPath, "resolvePeerSocketPath");
+__name(resolvePeerSocketCandidates, "resolvePeerSocketCandidates");
 function isLocalIpcPath(candidate) {
   if (typeof candidate !== "string" || candidate.length === 0) return false;
   if (candidate.includes("\0")) return false;
@@ -355,31 +357,39 @@ async function sendDeliveryStatus(socketPath, fields, authToken) {
   }
 }
 __name(sendDeliveryStatus, "sendDeliveryStatus");
-function probePeerSocket(socketPath) {
+function probePeerSocketVerdict(socketPath) {
   return new Promise((resolve) => {
     if (!isLocalIpcPath(socketPath)) {
-      resolve(false);
+      resolve("unknown");
       return;
     }
     const socket = net.connect({ path: socketPath });
     let settled = false;
-    const settle = /* @__PURE__ */ __name((alive) => {
+    const settle = /* @__PURE__ */ __name((verdict) => {
       if (settled) return;
       settled = true;
       clearTimeout(deadline);
       socket.destroy();
-      resolve(alive);
+      resolve(verdict);
     }, "settle");
-    const deadline = setTimeout(() => settle(false), PROBE_TIMEOUT_MS);
+    const deadline = setTimeout(() => settle("unknown"), PROBE_TIMEOUT_MS);
     deadline.unref();
-    socket.on("connect", () => settle(true));
-    socket.on(
-      "error",
-      (error) => settle(error.code === "EAGAIN" || error.code === "EBUSY")
-    );
+    socket.on("connect", () => settle("alive"));
+    socket.on("error", (error) => {
+      const code = error.code;
+      if (code === "EAGAIN" || code === "EBUSY") {
+        settle("alive");
+        return;
+      }
+      if (code === "ENOENT" || code === "ECONNREFUSED") {
+        settle("dead");
+        return;
+      }
+      settle("unknown");
+    });
   });
 }
-__name(probePeerSocket, "probePeerSocket");
+__name(probePeerSocketVerdict, "probePeerSocketVerdict");
 
 // packages/core/src/ipc/peer-directory.ts
 function peerRef(sessionId) {
@@ -405,9 +415,10 @@ __name(toPeerSessionInfo, "toPeerSessionInfo");
 async function listMessageablePeers() {
   const records = await listLiveSessions();
   const candidates = records.map(toPeerSessionInfo).filter((peer) => peer !== null);
-  const reachable = await Promise.all(
-    candidates.map((peer) => probePeerSocket(peer.ipcPath))
+  const verdicts = await Promise.all(
+    candidates.map((peer) => probePeerSocketVerdict(peer.ipcPath))
   );
+  const reachable = verdicts.map((verdict) => verdict === "alive");
   return dedupeSameNameTwins(candidates.filter((_, index) => reachable[index]));
 }
 __name(listMessageablePeers, "listMessageablePeers");
@@ -481,9 +492,6 @@ function isInProcessRecipient(address, team) {
 }
 __name(isInProcessRecipient, "isInProcessRecipient");
 
-// packages/core/src/ipc/peer-send.ts
-init_esbuild_shims();
-
 // packages/core/src/ipc/inbound-gate.ts
 init_esbuild_shims();
 var debugLogger2 = createDebugLogger("PEER_INBOUND");
@@ -493,10 +501,36 @@ function receiverReviewsActions(mode) {
   return mode !== "yolo" /* YOLO */ && mode !== "auto-edit" /* AUTO_EDIT */ && mode !== "auto" /* AUTO */;
 }
 __name(receiverReviewsActions, "receiverReviewsActions");
+function modeClass(mode) {
+  return receiverReviewsActions(mode) ? "prompting" : "bypass";
+}
+__name(modeClass, "modeClass");
 function isInboundPolicy(value) {
   return value === "accept" || value === "hold" || value === "refuse";
 }
 __name(isInboundPolicy, "isInboundPolicy");
+var MAX_TIMEOUT_MS = 2 ** 31 - 1;
+var DEFAULT_HELD_EXPIRY_MS = 5 * 60 * 1e3;
+var HELD_EXPIRY_VALUES = {
+  "1m": 60 * 1e3,
+  "5m": DEFAULT_HELD_EXPIRY_MS,
+  "10m": 10 * 60 * 1e3,
+  never: null
+};
+var HELD_EXPIRY_OPTIONS = Object.keys(HELD_EXPIRY_VALUES);
+function parseHeldExpiry(value) {
+  if (value === void 0) return DEFAULT_HELD_EXPIRY_MS;
+  if (typeof value !== "string" || !Object.hasOwn(HELD_EXPIRY_VALUES, value)) {
+    debugLogger2.debug(
+      `unrecognized crossSessionHeldExpiry value (using the default): ${String(
+        value
+      )}`
+    );
+    return DEFAULT_HELD_EXPIRY_MS;
+  }
+  return HELD_EXPIRY_VALUES[value] ?? null;
+}
+__name(parseHeldExpiry, "parseHeldExpiry");
 var InboundGate = class {
   constructor(options) {
     this.options = options;
@@ -514,10 +548,34 @@ var InboundGate = class {
    */
   settled = /* @__PURE__ */ new Map();
   shuttingDown = false;
+  /**
+   * One timer for the whole buffer, armed for the message that expires
+   * first. A timer per message would be up to `MAX_HELD_MESSAGES` of
+   * them, all firing to do the same sweep.
+   */
+  expiryTimer = null;
   /** Messages currently parked, oldest first. */
   getHeld() {
     return this.held;
   }
+  /**
+   * The current hold lifetime in milliseconds, or null when holds do not
+   * expire. Exposed so `/peers` can tell the user how long a message has
+   * left rather than making them guess.
+   */
+  getHeldExpiryMs() {
+    if (this.options.getHeldExpiryMs === void 0) {
+      return DEFAULT_HELD_EXPIRY_MS;
+    }
+    try {
+      return this.options.getHeldExpiryMs();
+    } catch (error) {
+      debugLogger2.debug(
+        `held-expiry getter threw; falling back to the default: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return DEFAULT_HELD_EXPIRY_MS;
+    }
+  }
   /**
    * Resolve the policy for a frame, and explain it.
    *
@@ -534,7 +592,7 @@ var InboundGate = class {
             configured
           )}`
         );
-        return { policy: "hold", cause: "policy-unreadable" };
+        return this.hold("policy-unreadable", this.policyScope());
       }
       explicit = configured;
     } catch (error) {
@@ -543,8 +601,11 @@ var InboundGate = class {
       );
       return { policy: "hold", cause: "policy-unreadable" };
     }
+    if (explicit === "hold") {
+      return this.hold("explicit-setting", this.policyScope());
+    }
     if (explicit !== void 0) {
-      return { policy: explicit, cause: "explicit-setting" };
+      return { policy: explicit };
     }
     if (origin?.selfSent) {
       return { policy: "accept" };
@@ -561,20 +622,32 @@ var InboundGate = class {
     if (mode === null || !APPROVAL_MODES.includes(mode)) {
       return { policy: "hold", cause: "mode-unknown" };
     }
-    if (receiverReviewsActions(mode)) {
-      return { policy: "accept" };
-    }
     const sender = frame?.fromMode;
     if (sender === void 0) {
       return { policy: "hold", cause: "no-mode-asserted" };
     }
-    return sender === "bypass" ? { policy: "accept" } : { policy: "hold", cause: "mode-mismatch" };
+    return sender === modeClass(mode) ? { policy: "accept" } : { policy: "hold", cause: "mode-mismatch" };
+  }
+  hold(cause, scope) {
+    return scope === void 0 ? { policy: "hold", cause } : { policy: "hold", cause, scope };
+  }
+  /** The scope is decoration on a cause; a broken getter must not change the verdict. */
+  policyScope() {
+    try {
+      return this.options.getPolicyScope?.();
+    } catch (error) {
+      debugLogger2.debug(
+        `policy-scope getter threw (ignored): ${error instanceof Error ? error.message : String(error)}`
+      );
+      return void 0;
+    }
   }
   /**
    * Run a freshly-arrived message through the gate. `origin` defaults to
    * an ordinary peer — the transport asserts self-sent, never the frame.
    */
   admit(frame, origin = { selfSent: false }) {
+    this.expireOverdue();
     const settled = this.settled.get(canonicalizeMsgId(frame.msgId));
     if (settled !== void 0) {
       debugLogger2.debug(
@@ -594,7 +667,8 @@ var InboundGate = class {
     const { policy } = decision;
     if (policy === "refuse") {
       debugLogger2.debug(`refused peer message ${frame.msgId}`);
-      void this.report(frame, "denied");
+      this.recordSettled(frame.msgId, "refused");
+      void this.report(frame, "refused");
       return "refused";
     }
     if (this.shuttingDown) {
@@ -621,10 +695,13 @@ var InboundGate = class {
       }
     }
     const cause = decision.policy === "hold" ? decision.cause : "mode-unknown";
+    const scope = decision.policy === "hold" ? decision.scope : void 0;
     this.held.push({
       frame,
       cause,
+      ...scope === void 0 ? {} : { policyScope: scope },
       heldAt: Date.now(),
+      monotonicAt: performance.now(),
       ...origin.selfSent ? { selfSent: true } : {}
     });
     debugLogger2.debug(
@@ -632,6 +709,7 @@ var InboundGate = class {
     );
     void this.report(frame, "held");
     this.notifyHeldChange();
+    this.rescheduleExpiry();
     return "held";
   }
   /**
@@ -647,6 +725,7 @@ var InboundGate = class {
    * retry; claiming 'done' would report a release that never happened.
    */
   decide(msgId, decision) {
+    this.expireOverdue();
     const index = this.held.findIndex((entry2) => entry2.frame.msgId === msgId);
     if (index === -1) return "gone";
     const [entry] = this.held.splice(index, 1);
@@ -656,12 +735,14 @@ var InboundGate = class {
         this.recordSettled(entry.frame.msgId, "misaddressed");
         void this.report(entry.frame, "misaddressed");
         this.notifyHeldChange();
+        this.rescheduleExpiry();
         return "gone";
       }
       if (!this.tryDeliver(entry.frame, originOf(entry))) {
         this.held.splice(index, 0, entry);
         void this.report(entry.frame, "held");
         this.notifyHeldChange();
+        this.rescheduleExpiry();
         return "failed";
       }
       this.recordSettled(entry.frame.msgId, "delivered");
@@ -671,6 +752,7 @@ var InboundGate = class {
       void this.report(entry.frame, "denied");
     }
     this.notifyHeldChange();
+    this.rescheduleExpiry();
     return "done";
   }
   /**
@@ -684,6 +766,8 @@ var InboundGate = class {
    * Returns the number of messages released.
    */
   reevaluate(reason) {
+    this.expireOverdue();
+    this.rescheduleExpiry();
     if (this.held.length === 0) return 0;
     const stillHeld = [];
     const release = [];
@@ -698,8 +782,7 @@ var InboundGate = class {
         this.recordSettled(entry.frame.msgId, "denied");
         void this.report(entry.frame, "denied");
       } else {
-        const cause = decision.policy === "hold" ? decision.cause : entry.cause;
-        stillHeld.push(cause === entry.cause ? entry : { ...entry, cause });
+        stillHeld.push(withCause(entry, decision));
       }
     }
     let released = 0;
@@ -721,7 +804,9 @@ var InboundGate = class {
       }
     }
     this.held.length = 0;
+    stillHeld.sort((a, b) => this.ageOf(b) - this.ageOf(a));
     this.held.push(...stillHeld);
+    this.rescheduleExpiry();
     if (release.length > 0 || dropped > 0) {
       debugLogger2.debug(
         `reevaluate (${reason}): released ${released}, dropped ${dropped}, misaddressed ${misaddressed}, ${this.held.length} still held`
@@ -738,6 +823,10 @@ var InboundGate = class {
    */
   shutdown() {
     this.shuttingDown = true;
+    if (this.expiryTimer !== null) {
+      clearTimeout(this.expiryTimer);
+      this.expiryTimer = null;
+    }
     if (this.held.length === 0) return Promise.resolve();
     const settling = this.held.splice(0, this.held.length);
     debugLogger2.debug(
@@ -801,6 +890,89 @@ var InboundGate = class {
       return false;
     }
   }
+  /**
+   * How long `entry` has been parked: the larger of the wall-clock and
+   * monotonic elapsed times.
+   *
+   * Neither clock alone is right. The wall clock is what a suspended
+   * machine advances -- CLOCK_MONOTONIC does not tick across suspend, so
+   * a monotonic-only age would keep a message parked through a two-hour
+   * sleep. But the wall clock also moves when nothing elapsed: a
+   * backward NTP correction of an hour would stretch a five-minute hold
+   * past sixty, and a step over ~24.8 days pushes the re-armed delay
+   * beyond setTimeout's range.
+   *
+   * Taking the larger keeps the suspend case working and makes a
+   * backward step a no-op, at the cost of treating a forward step as
+   * elapsed time -- which is the conservative direction, and in any case
+   * a forward step is indistinguishable from a suspend from in here.
+   */
+  ageOf(entry) {
+    const wall = Date.now() - entry.heldAt;
+    if (entry.monotonicAt === void 0) return wall;
+    return Math.max(wall, performance.now() - entry.monotonicAt);
+  }
+  /**
+   * Settle every message whose hold has run out.
+   *
+   * Expiry is judged against the lifetime configured *now*, not the one
+   * in force when each message arrived: shortening the setting expires a
+   * backlog that is already too old, and lengthening it gives the
+   * backlog the longer window. Either reading is defensible; this one
+   * has the property that what `/peers` shows as remaining is what
+   * actually happens.
+   */
+  expireOverdue() {
+    const expiryMs = this.getHeldExpiryMs();
+    if (expiryMs === null || this.held.length === 0) return;
+    const survivors = [];
+    const expired = [];
+    for (const entry of this.held) {
+      (this.ageOf(entry) >= expiryMs ? expired : survivors).push(entry);
+    }
+    if (expired.length === 0) return;
+    this.held.length = 0;
+    this.held.push(...survivors);
+    for (const entry of expired) {
+      debugLogger2.debug(
+        `held peer message ${entry.frame.msgId} expired after ${expiryMs} ms`
+      );
+      this.recordSettled(entry.frame.msgId, "expired");
+      void this.report(entry.frame, "expired");
+    }
+    this.notifyHeldChange();
+    this.rescheduleExpiry();
+  }
+  /**
+   * Arm the timer for whichever message expires first, or clear it when
+   * nothing is waiting and when holds do not expire.
+   *
+   * Called after every change to the buffer. Unref'd: a session with a
+   * message parked should still be able to exit, and shutdown settles
+   * the backlog anyway.
+   */
+  rescheduleExpiry() {
+    if (this.expiryTimer !== null) {
+      clearTimeout(this.expiryTimer);
+      this.expiryTimer = null;
+    }
+    if (this.shuttingDown) return;
+    const expiryMs = this.getHeldExpiryMs();
+    if (expiryMs === null) return;
+    let oldestAge = null;
+    for (const entry of this.held) {
+      const age = this.ageOf(entry);
+      if (oldestAge === null || age > oldestAge) oldestAge = age;
+    }
+    if (oldestAge === null) return;
+    const delay = Math.min(MAX_TIMEOUT_MS, Math.max(1, expiryMs - oldestAge));
+    this.expiryTimer = setTimeout(() => {
+      this.expiryTimer = null;
+      this.expireOverdue();
+      this.rescheduleExpiry();
+    }, delay);
+    this.expiryTimer.unref?.();
+  }
   notifyHeldChange() {
     try {
       this.options.onHeldChange?.(this.held);
@@ -815,18 +987,40 @@ function originOf(entry) {
   return { selfSent: entry.selfSent === true };
 }
 __name(originOf, "originOf");
-function describeHoldCause(cause) {
+function withCause(entry, decision) {
+  if (decision.policy !== "hold") return entry;
+  const { cause, scope } = decision;
+  if (cause === entry.cause && scope === entry.policyScope) return entry;
+  const { policyScope: _dropped, ...rest } = entry;
+  return scope === void 0 ? { ...rest, cause } : { ...rest, cause, policyScope: scope };
+}
+__name(withCause, "withCause");
+function describeHoldCause(cause, scope) {
   switch (cause) {
     case "explicit-setting":
-      return 'your crossSessionInbound setting is "hold"';
+      switch (scope) {
+        case "workspace":
+          return `this repository's settings hold messages from other sessions (agents.crossSessionInbound is "hold" in workspace settings)`;
+        case "system":
+          return 'a system setting holds messages from other sessions (agents.crossSessionInbound is "hold" in system settings)';
+        default:
+          return 'your crossSessionInbound setting is "hold"';
+      }
     case "mode-mismatch":
-      return "this session can apply some actions without per-action review and the sender does not";
+      return "the sender and this session are in different review modes: one reviews each action and the other can apply some without per-action review";
     case "no-mode-asserted":
-      return "this session can apply some actions without per-action review and the sender did not say whether it does";
+      return "the sender did not say whether it reviews each action";
     case "mode-unknown":
       return "this session's approval mode could not be determined";
     case "policy-unreadable":
-      return "your crossSessionInbound setting could not be read";
+      switch (scope) {
+        case "workspace":
+          return "the agents.crossSessionInbound value in this repository's workspace settings could not be read";
+        case "system":
+          return "the agents.crossSessionInbound value in system settings could not be read";
+        default:
+          return "your crossSessionInbound setting could not be read";
+      }
     default: {
       const exhaustive = cause;
       return exhaustive;
@@ -836,6 +1030,7 @@ function describeHoldCause(cause) {
 __name(describeHoldCause, "describeHoldCause");
 
 // packages/core/src/ipc/peer-send.ts
+init_esbuild_shims();
 async function getOwnPeerIdentity() {
   const record = await readOwnSessionRecord();
   const self = record === null ? null : toPeerSessionInfo(record);
@@ -849,7 +1044,7 @@ async function getOwnPeerIdentity() {
 }
 __name(getOwnPeerIdentity, "getOwnPeerIdentity");
 function senderModeClass(mode) {
-  return receiverReviewsActions(mode) ? "prompting" : "bypass";
+  return modeClass(mode);
 }
 __name(senderModeClass, "senderModeClass");
 var MAX_TRACKED_SENDS = 200;
@@ -866,10 +1061,21 @@ function trackSent(msgId, info) {
 }
 __name(trackSent, "trackSent");
 var RECEIPT_TRANSITIONS = {
-  pending: /* @__PURE__ */ new Set(["held", "delivered", "denied", "expired", "misaddressed"]),
+  pending: /* @__PURE__ */ new Set([
+    "held",
+    "delivered",
+    "denied",
+    "refused",
+    "expired",
+    "misaddressed"
+  ]),
+  // A refusal is decided at admission, so it cannot follow a hold: a
+  // message already parked was not turned away. Switching the setting to
+  // `refuse` while it sits there settles it as `denied` — someone chose.
   held: /* @__PURE__ */ new Set(["delivered", "denied", "expired", "misaddressed"]),
   delivered: /* @__PURE__ */ new Set(["expired", "misaddressed"]),
   denied: /* @__PURE__ */ new Set(),
+  refused: /* @__PURE__ */ new Set(),
   expired: /* @__PURE__ */ new Set(),
   misaddressed: /* @__PURE__ */ new Set()
 };
@@ -1006,13 +1212,17 @@ export {
   parsePeerFrame,
   describeDeliveryStatus,
   parsePeerAuthLine,
-  resolvePeerSocketPath,
+  MAX_SOCKET_PATH_BYTES,
+  SOCKET_DIR_NAME,
+  resolvePeerSocketCandidates,
   isLocalIpcPath,
   sendDeliveryStatus,
+  probePeerSocketVerdict,
   listMessageablePeers,
   advertisablePeerAddress,
   isInProcessRecipient,
   MAX_HELD_MESSAGES,
+  parseHeldExpiry,
   InboundGate,
   describeHoldCause,
   getOwnPeerIdentity,

package/chunks/{chunk-LOBDDFYK.js → chunk-HJ34U5J4.js}

@@ -2,11 +2,11 @@
 "use strict";
 import {
   t
-} from "./chunk-I4NRYS6A.js";
+} from "./chunk-MUZCSTOO.js";
 import {
   SessionReferenceService,
   readManyFiles
-} from "./chunk-JUARRUMA.js";
+} from "./chunk-UEZOXZNI.js";
 import {
   emptyMcpResourceText,
   formatMcpResourceContents,
@@ -15,10 +15,10 @@ import {
 import {
   SessionService,
   stripTerminalControlSequences
-} from "./chunk-4F7GQGXB.js";
+} from "./chunk-I72PHOKL.js";
 import {
   shouldRunVisionBridge
-} from "./chunk-GH2S4GD5.js";
+} from "./chunk-P5LDR7FI.js";
 import {
   Storage,
   getErrorMessage,
@@ -26,7 +26,7 @@ import {
   isSubpath,
   unescapePath,
   unescapeShellSpecials
-} from "./chunk-EAHOJF6V.js";
+} from "./chunk-ZAFYHRVY.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-M4LBBSVP.js → chunk-HY3DXYZK.js}

@@ -2,10 +2,10 @@
 "use strict";
 import {
   wrapForMultiplexer
-} from "./chunk-3AKCBZVW.js";
+} from "./chunk-VU7O7CGQ.js";
 import {
   createDebugLogger
-} from "./chunk-EAHOJF6V.js";
+} from "./chunk-ZAFYHRVY.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";