@qwen-code/qwen-code 0.21.12 → 0.21.13

package/chunks/chunk-TS6625XH.js

@@ -0,0 +1,488 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  LIVE_HOST_PROTOCOL_VERSION
+} from "./chunk-NKLP3DCK.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/serve/live/discovery.ts
+init_esbuild_shims();
+import { randomUUID } from "node:crypto";
+import { constants as fsConstants } from "node:fs";
+import * as fs from "node:fs/promises";
+import { isIP } from "node:net";
+import { homedir } from "node:os";
+import * as path from "node:path";
+var LIVE_DISCOVERY_RELATIVE_PATH = path.join("live", "daemon.json");
+var MAX_DISCOVERY_BYTES = 16 * 1024;
+var NONCE_PATTERN = /^[A-Za-z0-9_-]{16,256}$/;
+var DEFAULT_HANDOFF_GRACE_MS = 1e3;
+var LOCK_OPTIONS = {
+  realpath: false,
+  stale: 1e4,
+  update: 2e3,
+  retries: {
+    retries: 120,
+    minTimeout: 10,
+    maxTimeout: 100,
+    factor: 1.2,
+    randomize: true
+  }
+};
+var LiveDiscoveryOwnerActiveError = class extends Error {
+  constructor(ownerPid) {
+    super(`Live discovery is owned by active daemon pid ${ownerPid}.`);
+    this.ownerPid = ownerPid;
+    this.name = "LiveDiscoveryOwnerActiveError";
+  }
+  static {
+    __name(this, "LiveDiscoveryOwnerActiveError");
+  }
+};
+var LiveDiscoveryStateError = class extends Error {
+  static {
+    __name(this, "LiveDiscoveryStateError");
+  }
+  constructor(cause) {
+    super("Existing Live discovery record is invalid.", { cause });
+    this.name = "LiveDiscoveryStateError";
+  }
+};
+var LiveDiscoveryPublicationError = class extends Error {
+  static {
+    __name(this, "LiveDiscoveryPublicationError");
+  }
+  published = true;
+  constructor(cause) {
+    super("Live discovery publication completed with cleanup errors.", {
+      cause
+    });
+    this.name = "LiveDiscoveryPublicationError";
+  }
+};
+function getStableLiveDiscoveryBaseDir(homeDirectory = homedir()) {
+  return path.join(homeDirectory, ".qwen");
+}
+__name(getStableLiveDiscoveryBaseDir, "getStableLiveDiscoveryBaseDir");
+function getLiveDiscoveryPath(runtimeBaseDir) {
+  return path.join(runtimeBaseDir, LIVE_DISCOVERY_RELATIVE_PATH);
+}
+__name(getLiveDiscoveryPath, "getLiveDiscoveryPath");
+function assertSafeRecord(record) {
+  if (typeof record.url !== "string" || typeof record.instanceNonce !== "string" || record.token !== void 0 && typeof record.token !== "string") {
+    throw new Error("Live discovery record is invalid.");
+  }
+  let url;
+  try {
+    url = new URL(record.url);
+  } catch {
+    throw new Error("Live discovery URL is invalid.");
+  }
+  const hostname = url.hostname.replace(/^\[|\]$/g, "").toLowerCase();
+  const loopback = hostname === "localhost" || hostname === "::1" || isIP(hostname) === 4 && hostname.startsWith("127.");
+  if (url.protocol !== "http:" && url.protocol !== "https:" || !loopback || url.username.length > 0 || url.password.length > 0) {
+    throw new Error("Live discovery URL must be a loopback HTTP URL.");
+  }
+  if (!Number.isSafeInteger(record.protocolVersion) || record.protocolVersion <= 0 || !Number.isSafeInteger(record.pid) || record.pid <= 0 || !NONCE_PATTERN.test(record.instanceNonce) || record.token !== void 0 && (record.token.length === 0 || record.token.length > 4096)) {
+    throw new Error("Live discovery record is invalid.");
+  }
+}
+__name(assertSafeRecord, "assertSafeRecord");
+function assertRecord(record) {
+  assertSafeRecord(record);
+  if (record.protocolVersion !== LIVE_HOST_PROTOCOL_VERSION) {
+    throw new Error("Live discovery record is invalid.");
+  }
+}
+__name(assertRecord, "assertRecord");
+function processIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code !== "ESRCH";
+  }
+}
+__name(processIsAlive, "processIsAlive");
+function delay(milliseconds) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, milliseconds);
+  });
+}
+__name(delay, "delay");
+async function readExistingRecord(filePath) {
+  let stat;
+  try {
+    stat = await fs.lstat(filePath);
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+  if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1 || process.platform !== "win32" && ((stat.mode & 511) !== 384 || typeof process.getuid === "function" && stat.uid !== process.getuid()) || stat.size <= 0 || stat.size > MAX_DISCOVERY_BYTES) {
+    throw new LiveDiscoveryStateError();
+  }
+  let handle;
+  try {
+    handle = await fs.open(
+      filePath,
+      process.platform === "win32" ? fsConstants.O_RDONLY : fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW
+    );
+  } catch {
+    throw new LiveDiscoveryStateError();
+  }
+  try {
+    const handleStat = await handle.stat();
+    if (!handleStat.isFile() || handleStat.nlink !== 1 || handleStat.dev !== stat.dev || handleStat.ino !== stat.ino || handleStat.size !== stat.size || process.platform !== "win32" && ((handleStat.mode & 511) !== 384 || typeof process.getuid === "function" && handleStat.uid !== process.getuid())) {
+      throw new LiveDiscoveryStateError();
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(await handle.readFile("utf8"));
+    } catch {
+      throw new LiveDiscoveryStateError();
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new LiveDiscoveryStateError();
+    }
+    const record = parsed;
+    try {
+      assertSafeRecord(record);
+    } catch {
+      throw new LiveDiscoveryStateError();
+    }
+    return record;
+  } finally {
+    await handle.close();
+  }
+}
+__name(readExistingRecord, "readExistingRecord");
+async function inspectDirectory(directory, requirePrivateMode = true) {
+  const stat = await fs.lstat(directory);
+  if (!stat.isDirectory() || stat.isSymbolicLink() || process.platform !== "win32" && (requirePrivateMode && (stat.mode & 511) !== 448 || typeof process.getuid === "function" && stat.uid !== process.getuid())) {
+    throw new LiveDiscoveryStateError();
+  }
+  return { directory, dev: stat.dev, ino: stat.ino };
+}
+__name(inspectDirectory, "inspectDirectory");
+async function assertDirectoryIdentity(expected, requirePrivateMode = true) {
+  const current = await inspectDirectory(
+    expected.directory,
+    requirePrivateMode
+  );
+  if (current.dev !== expected.dev || current.ino !== expected.ino) {
+    throw new LiveDiscoveryStateError();
+  }
+}
+__name(assertDirectoryIdentity, "assertDirectoryIdentity");
+async function ensureDirectory(directory, requirePrivateMode) {
+  try {
+    return await inspectDirectory(directory, requirePrivateMode);
+  } catch (error) {
+    try {
+      await fs.lstat(directory);
+      throw error;
+    } catch (statError) {
+      if (statError.code !== "ENOENT") throw error;
+    }
+  }
+  const parent = path.dirname(directory);
+  if (parent === directory) throw new LiveDiscoveryStateError();
+  const parentIdentity = await ensureDirectory(parent, false);
+  await assertDirectoryIdentity(parentIdentity, false);
+  let created = false;
+  try {
+    await fs.mkdir(directory, { mode: 448 });
+    created = true;
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+  }
+  if (created && process.platform !== "win32") {
+    await fs.chmod(directory, 448);
+  }
+  await assertDirectoryIdentity(parentIdentity, false);
+  return inspectDirectory(directory, requirePrivateMode);
+}
+__name(ensureDirectory, "ensureDirectory");
+async function assertLockShapeIfPresent(lockPath) {
+  let stat;
+  try {
+    stat = await fs.lstat(lockPath);
+  } catch (error) {
+    if (error.code === "ENOENT") return;
+    throw error;
+  }
+  if (!stat.isDirectory() || stat.isSymbolicLink() || process.platform !== "win32" && typeof process.getuid === "function" && stat.uid !== process.getuid()) {
+    throw new LiveDiscoveryStateError();
+  }
+}
+__name(assertLockShapeIfPresent, "assertLockShapeIfPresent");
+async function prepareDirectory(runtimeBaseDir, create = true) {
+  const directory = path.dirname(getLiveDiscoveryPath(runtimeBaseDir));
+  let runtimeBaseIdentity;
+  try {
+    runtimeBaseIdentity = await inspectDirectory(runtimeBaseDir, false);
+  } catch (error) {
+    try {
+      await fs.lstat(runtimeBaseDir);
+      throw error;
+    } catch (statError) {
+      if (statError.code !== "ENOENT") throw error;
+    }
+    if (!create) return void 0;
+    runtimeBaseIdentity = await ensureDirectory(runtimeBaseDir, false);
+  }
+  let created = false;
+  try {
+    const identity = await inspectDirectory(directory);
+    await assertDirectoryIdentity(runtimeBaseIdentity, false);
+    return identity;
+  } catch (error) {
+    try {
+      await fs.lstat(directory);
+      throw error;
+    } catch (statError) {
+      if (statError.code !== "ENOENT") throw error;
+    }
+  }
+  if (!create) return void 0;
+  await assertDirectoryIdentity(runtimeBaseIdentity, false);
+  try {
+    await fs.mkdir(directory, { mode: 448 });
+    created = true;
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+  }
+  if (created && process.platform !== "win32") {
+    await fs.chmod(directory, 448);
+  }
+  await assertDirectoryIdentity(runtimeBaseIdentity, false);
+  return inspectDirectory(directory);
+}
+__name(prepareDirectory, "prepareDirectory");
+async function lockDirectory(target) {
+  const lockPath = path.join(target.directory, ".daemon.lock");
+  await assertLockShapeIfPresent(lockPath);
+  const lockfile = (await import("./proper-lockfile-3LHWIM44.js")).default;
+  let compromised = false;
+  const release = await lockfile.lock(target.directory, {
+    ...LOCK_OPTIONS,
+    lockfilePath: lockPath,
+    onCompromised: /* @__PURE__ */ __name(() => {
+      compromised = true;
+    }, "onCompromised")
+  });
+  try {
+    await assertLockShapeIfPresent(lockPath);
+  } catch (error) {
+    let releaseError;
+    await release().catch((candidate) => {
+      releaseError = candidate;
+    });
+    throw new LiveDiscoveryStateError(
+      releaseError ? new AggregateError(
+        [error, releaseError],
+        "Live discovery lock validation cleanup failed."
+      ) : error
+    );
+  }
+  return {
+    release,
+    assertHealthy: /* @__PURE__ */ __name(() => {
+      if (compromised) throw new LiveDiscoveryStateError();
+    }, "assertHealthy")
+  };
+}
+__name(lockDirectory, "lockDirectory");
+async function syncDirectory(directory) {
+  if (process.platform === "win32") return;
+  const handle = await fs.open(directory, "r");
+  try {
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+}
+__name(syncDirectory, "syncDirectory");
+async function handoffLiveDiscoveryOwner(runtimeBaseDir, owner, commitOwner, options = {}) {
+  const target = await prepareDirectory(runtimeBaseDir, false);
+  if (!target) {
+    await commitOwner();
+    return { reclaimed: false };
+  }
+  const lock = await lockDirectory(target);
+  let result;
+  let operationError;
+  try {
+    lock.assertHealthy();
+    await assertDirectoryIdentity(target);
+    const filePath = getLiveDiscoveryPath(runtimeBaseDir);
+    const current = await readExistingRecord(filePath);
+    if (current && (current.pid !== owner.pid || current.instanceNonce !== owner.instanceNonce)) {
+      if (current.pid === owner.pid || (options.isProcessAlive ?? processIsAlive)(current.pid)) {
+        throw new LiveDiscoveryOwnerActiveError(current.pid);
+      }
+      await commitOwner();
+      lock.assertHealthy();
+      await assertDirectoryIdentity(target);
+      const confirmed = await readExistingRecord(filePath);
+      if (!confirmed || confirmed.pid !== current.pid || confirmed.instanceNonce !== current.instanceNonce) {
+        throw new LiveDiscoveryStateError();
+      }
+      lock.assertHealthy();
+      await assertDirectoryIdentity(target);
+      await fs.unlink(filePath);
+      await syncDirectory(target.directory);
+      lock.assertHealthy();
+      result = { reclaimed: true };
+    } else {
+      await commitOwner();
+      lock.assertHealthy();
+      result = { reclaimed: false };
+    }
+  } catch (error) {
+    operationError = error;
+  }
+  let releaseError;
+  await lock.release().catch((error) => {
+    releaseError = error;
+  });
+  if (releaseError) {
+    throw new LiveDiscoveryStateError(
+      operationError ? new AggregateError(
+        [operationError, releaseError],
+        "Live discovery handoff cleanup failed."
+      ) : releaseError
+    );
+  }
+  if (operationError) throw operationError;
+  if (result?.reclaimed && options.waitForHandoffGrace !== false) {
+    await (options.wait ?? delay)(
+      options.handoffGraceMs ?? DEFAULT_HANDOFF_GRACE_MS
+    );
+  }
+  return result;
+}
+__name(handoffLiveDiscoveryOwner, "handoffLiveDiscoveryOwner");
+async function writeLiveDiscoveryFile(runtimeBaseDir, record, options = {}) {
+  assertRecord(record);
+  const target = await prepareDirectory(runtimeBaseDir);
+  if (!target) throw new LiveDiscoveryStateError();
+  const { directory } = target;
+  const filePath = getLiveDiscoveryPath(runtimeBaseDir);
+  const temporaryPath = path.join(
+    directory,
+    `.daemon.${process.pid}.${randomUUID()}.tmp`
+  );
+  const lock = await lockDirectory(target);
+  let handle;
+  let operationError;
+  let operationSucceeded = false;
+  let published = false;
+  try {
+    lock.assertHealthy();
+    await assertDirectoryIdentity(target);
+    const current = await readExistingRecord(filePath);
+    if (current && (current.pid !== record.pid || current.instanceNonce !== record.instanceNonce)) {
+      if ((options.isProcessAlive ?? processIsAlive)(current.pid)) {
+        throw new LiveDiscoveryOwnerActiveError(current.pid);
+      }
+      throw new LiveDiscoveryStateError();
+    }
+    handle = await fs.open(temporaryPath, "wx", 384);
+    const serialized = `${JSON.stringify(record)}
+`;
+    if (Buffer.byteLength(serialized) > MAX_DISCOVERY_BYTES) {
+      throw new Error("Live discovery record is too large.");
+    }
+    await handle.writeFile(serialized, "utf8");
+    await handle.chmod(384);
+    await handle.sync();
+    await handle.close();
+    handle = void 0;
+    lock.assertHealthy();
+    await assertDirectoryIdentity(target);
+    await fs.rename(temporaryPath, filePath);
+    published = true;
+    await syncDirectory(directory);
+    lock.assertHealthy();
+    operationSucceeded = true;
+  } catch (error) {
+    operationError = error;
+  }
+  const cleanupErrors = [];
+  await handle?.close().catch((error) => cleanupErrors.push(error));
+  await fs.unlink(temporaryPath).catch((error) => {
+    if (error.code !== "ENOENT") cleanupErrors.push(error);
+  });
+  await lock.release().catch((error) => cleanupErrors.push(error));
+  if (!operationSucceeded) {
+    const cause = cleanupErrors.length > 0 ? new AggregateError(
+      [operationError, ...cleanupErrors],
+      "Live discovery publication cleanup failed."
+    ) : operationError;
+    if (published) throw new LiveDiscoveryPublicationError(cause);
+    if (cleanupErrors.length > 0) {
+      throw cause;
+    }
+    throw operationError;
+  }
+  if (cleanupErrors.length > 0) {
+    throw new LiveDiscoveryPublicationError(
+      new AggregateError(
+        cleanupErrors,
+        "Live discovery publication cleanup failed."
+      )
+    );
+  }
+  return filePath;
+}
+__name(writeLiveDiscoveryFile, "writeLiveDiscoveryFile");
+async function removeLiveDiscoveryFile(runtimeBaseDir, owner) {
+  if (!NONCE_PATTERN.test(owner.instanceNonce) || !Number.isSafeInteger(owner.pid) || owner.pid <= 0) {
+    throw new LiveDiscoveryStateError();
+  }
+  const target = await prepareDirectory(runtimeBaseDir, false);
+  if (!target) return false;
+  const filePath = getLiveDiscoveryPath(runtimeBaseDir);
+  const lock = await lockDirectory(target);
+  try {
+    lock.assertHealthy();
+    await assertDirectoryIdentity(target);
+    const current = await readExistingRecord(filePath);
+    if (!current) return false;
+    if (current.instanceNonce !== owner.instanceNonce || current.pid !== owner.pid) {
+      throw new LiveDiscoveryStateError();
+    }
+    lock.assertHealthy();
+    await assertDirectoryIdentity(target);
+    await fs.unlink(filePath);
+    await syncDirectory(target.directory);
+    lock.assertHealthy();
+    return true;
+  } finally {
+    await lock.release();
+  }
+}
+__name(removeLiveDiscoveryFile, "removeLiveDiscoveryFile");
+
+export {
+  LIVE_DISCOVERY_RELATIVE_PATH,
+  LiveDiscoveryOwnerActiveError,
+  LiveDiscoveryStateError,
+  LiveDiscoveryPublicationError,
+  getStableLiveDiscoveryBaseDir,
+  getLiveDiscoveryPath,
+  handoffLiveDiscoveryOwner,
+  writeLiveDiscoveryFile,
+  removeLiveDiscoveryFile
+};
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-WM3LUQLO.js → chunk-TUGSVUJB.js}

@@ -2,26 +2,26 @@
 "use strict";
 import {
   getExtensionManager
-} from "./chunk-IH4Z54RJ.js";
+} from "./chunk-QV5YN5YD.js";
 import {
   parseChannelConfig
-} from "./chunk-BSR5AXZR.js";
+} from "./chunk-OD2WU5QY.js";
 import {
   getPlugin,
   registerPlugin
-} from "./chunk-OK47XBYH.js";
+} from "./chunk-A4QRWUDE.js";
 import {
   sanitizeLogText
 } from "./chunk-AW27A43Y.js";
 import {
   loadSettings
-} from "./chunk-3GDBZJD6.js";
+} from "./chunk-A267JX7H.js";
 import {
   hashDaemonWorkspace
-} from "./chunk-K34GJQOZ.js";
+} from "./chunk-TIGA2IVL.js";
 import {
   Storage
-} from "./chunk-HOSVOUDK.js";
+} from "./chunk-BUQDLC2G.js";
 import {
   writeStderrLine,
   writeStdoutLine

package/chunks/{chunk-XAFIL4BD.js → chunk-U3VNBPUO.js}

@@ -3,18 +3,18 @@
 import {
   require_semver
 } from "./chunk-2AUM35J5.js";
-import {
-  t
-} from "./chunk-IRSLAS4M.js";
 import {
   getNpmCliPath
-} from "./chunk-7KJPO7YH.js";
+} from "./chunk-BKPPWD33.js";
+import {
+  t
+} from "./chunk-HUTNYWBG.js";
 import {
   getPackageJson
 } from "./chunk-WZMH7II3.js";
 import {
   createDebugLogger
-} from "./chunk-HOSVOUDK.js";
+} from "./chunk-BUQDLC2G.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-WDVDVWJ3.js → chunk-UKMR3CKV.js}

@@ -2,20 +2,20 @@
 "use strict";
 import {
   performStandaloneUpdate
-} from "./chunk-OPVF453Q.js";
+} from "./chunk-NEFOOD54.js";
 import {
   updateEventEmitter
 } from "./chunk-YAF2MQZ6.js";
-import {
-  t
-} from "./chunk-IRSLAS4M.js";
 import {
   getInstallationInfo,
   resolveUpdateCommand
-} from "./chunk-7KJPO7YH.js";
+} from "./chunk-BKPPWD33.js";
+import {
+  t
+} from "./chunk-HUTNYWBG.js";
 import {
   createDebugLogger
-} from "./chunk-HOSVOUDK.js";
+} from "./chunk-BUQDLC2G.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-DEDESZDL.js → chunk-UPDOZBWO.js}

@@ -5,7 +5,7 @@ import {
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-YIGGWOJE.js";
+} from "./chunk-6HY6IF3Z.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-MUNA4QDC.js → chunk-UZPM4XHR.js}

@@ -2,17 +2,17 @@
 "use strict";
 import {
   functionResponsePartsToString
-} from "./chunk-QSD4UH74.js";
+} from "./chunk-NNHNLJ2X.js";
 import {
   projectJsonStringToByteBudget
-} from "./chunk-UI5UGEF4.js";
+} from "./chunk-RLKC46YT.js";
 import {
   parseAndFormatApiError
-} from "./chunk-EBPLKY6U.js";
+} from "./chunk-4S5337WV.js";
 import {
   formatVisionBridgeNoticeDisplay,
   isVisionBridgeNoticeDisplay
-} from "./chunk-4KM2SYK5.js";
+} from "./chunk-RVOJ2FBP.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-6SPD4Z7F.js → chunk-V26NVGAU.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   BaseJsonOutputAdapter
-} from "./chunk-MUNA4QDC.js";
+} from "./chunk-UZPM4XHR.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-XDRXOSAD.js → chunk-V57QC6WW.js}

@@ -9,7 +9,7 @@ import {
   relaxSchemaForFunctionCalling,
   safeJsonParse,
   setGenAiUsageProvenance
-} from "./chunk-QLTATTPS.js";
+} from "./chunk-5CVO7YES.js";
 import {
   setToolCallPreparations
 } from "./chunk-GLCZKT5V.js";
@@ -21,7 +21,7 @@ import {
 } from "./chunk-46UV252V.js";
 import {
   createDebugLogger
-} from "./chunk-HOSVOUDK.js";
+} from "./chunk-BUQDLC2G.js";
 import {
   FinishReason,
   GenerateContentResponse

package/chunks/{chunk-NX4A23LY.js → chunk-WFSTRPRO.js}

@@ -2,11 +2,11 @@
 "use strict";
 import {
   createTask
-} from "./chunk-YILJKX2T.js";
+} from "./chunk-CKSJECTU.js";
 import {
   getPlanRequiredTeammatePreApprovalMessage,
   isPlanRequiredTeammateAwaitingApproval
-} from "./chunk-63FNZTWG.js";
+} from "./chunk-RWDNJBWN.js";
 import {
   resolveActiveTeamName
 } from "./chunk-S6LOFUVP.js";
@@ -15,7 +15,7 @@ import {
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-YIGGWOJE.js";
+} from "./chunk-6HY6IF3Z.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-H7TMVHKE.js → chunk-WGHHA7ZH.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   expandHomeDir
-} from "./chunk-HOSVOUDK.js";
+} from "./chunk-BUQDLC2G.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-JRIVMPD2.js → chunk-WSH6GRKG.js}

@@ -2,20 +2,20 @@
 "use strict";
 import {
   getInboxesDir
-} from "./chunk-D2RNVVH6.js";
+} from "./chunk-OVZPVYZB.js";
 import {
   require_proper_lockfile
-} from "./chunk-KRXPRVGL.js";
+} from "./chunk-MLXTMF7H.js";
 import {
   Mutex
 } from "./chunk-VGC4I5JJ.js";
 import {
   atomicWriteJSON
-} from "./chunk-YBHUXEC6.js";
+} from "./chunk-FDGGZIYW.js";
 import {
   createDebugLogger,
   isNodeError
-} from "./chunk-HOSVOUDK.js";
+} from "./chunk-BUQDLC2G.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";