nolo-cli 0.206.1 → 0.207.0

package/{chunk-73PRLLT6.js → chunk-EI77BHWD.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-YGILMZ7N.js";
 import {
   getReadableCliDb
-} from "./chunk-7DQSP7JU.js";
+} from "./chunk-J5JTMQIA.js";
 import {
   buildCreatedAgentRecord,
   buildUpdatedAgentRecord,
@@ -13,13 +13,13 @@ import {
   resolveAgentRecordFromHybridStore,
   sanitizeAgentRecordForCliOutput,
   writeAgentRecord
-} from "./chunk-2PW2KOII.js";
+} from "./chunk-XBZDTBTK.js";
 import {
   clearCliLocalRuntimePreparedAgentCache
-} from "./chunk-3UCYYSKN.js";
+} from "./chunk-7VTNQXNS.js";
 import {
   readCredentialAvailability
-} from "./chunk-W45PCJHS.js";
+} from "./chunk-R56VAYY4.js";
 import {
   resolveCliAgentKeyInput
 } from "./chunk-NBTY7YJF.js";
@@ -244,7 +244,7 @@ async function runAgentCreateCommand(args, deps = {}) {
     let verifyResult;
     if (parsed.verify) {
       try {
-        const { verifyCustomProvider } = await import("./agentProviderCommands-SKW4L6NN.js");
+        const { verifyCustomProvider } = await import("./agentProviderCommands-EMKA6NAN.js");
         const rec = built.nextRecord;
         verifyResult = await verifyCustomProvider({
           providerUrl: rec.customProviderUrl,

package/{chunk-WPOKOKZA.js → chunk-EPRYABUO.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-YUA6OAH5.js";
 import {
   CLI_PROVIDER_VALUES
-} from "./chunk-5BHQICF2.js";
+} from "./chunk-E32ZPIX6.js";
 import {
   normalizeServerOrigin
 } from "./chunk-CF7PE763.js";

package/{chunk-WC6TH54L.js → chunk-FSGQN6RC.js}

@@ -1,16 +1,16 @@
 import {
   createCliLocalRuntimeAdapter,
   summarizeEndpoint
-} from "./chunk-3UCYYSKN.js";
+} from "./chunk-7VTNQXNS.js";
 import {
   clipMultilineText
-} from "./chunk-QSAUX2Q2.js";
+} from "./chunk-7WSZHITX.js";
 import {
   runLocalAgentTurn
-} from "./chunk-ZRDUMMDG.js";
+} from "./chunk-XDLQYUBV.js";
 import {
   applyToolSurfaceConstraints
-} from "./chunk-2Q3LOAFE.js";
+} from "./chunk-6HVBI6TI.js";
 import {
   resolveLocalRuntimeEnvFromPolicy
 } from "./chunk-TRZP7JZ7.js";
@@ -38,7 +38,7 @@ import {
 } from "./chunk-4O22PGNQ.js";
 import {
   t
-} from "./chunk-PPCUXO3E.js";
+} from "./chunk-3RQVYR4B.js";
 import {
   asTrimmedNonEmptyStringArray
 } from "./chunk-I42VC5KR.js";

package/{chunk-7LJEJV4F.js → chunk-GMEAELJ6.js}

@@ -70,6 +70,85 @@ function parseResetsInMs(text) {
 var DEFAULT_QUOTA_BREAKER_MS = 6 * 3600 * 1e3;
 var DEFAULT_AGENT_NOT_FOUND_BREAKER_MS = 15 * 60 * 1e3;
 
+// packages/ai/agent/quotaSnapshot.ts
+function isQuotaWindowExpired(window, now) {
+  const resetAt = window?.resetAt;
+  return typeof resetAt === "number" && Number.isFinite(resetAt) && resetAt <= now;
+}
+function findTightestQuotaWindow(quota, now = Date.now()) {
+  if (!quota || !Array.isArray(quota.windows) || quota.windows.length === 0) {
+    return void 0;
+  }
+  let best;
+  let bestScore = -Infinity;
+  for (const w of quota.windows) {
+    let score = 0;
+    if (typeof w.utilization === "number" && w.utilization >= 0) {
+      score = 500 + Math.min(w.utilization, 1) * 500;
+    } else if (typeof w.remaining === "number" && typeof w.limit === "number" && w.limit > 0) {
+      const util = Math.max(0, 1 - w.remaining / w.limit);
+      score = 500 + util * 500;
+    } else if (typeof w.resetAt === "number" && w.resetAt > now) {
+      score = 200;
+    } else if (typeof w.remaining === "number") {
+      score = 100;
+    }
+    if (score > bestScore) {
+      bestScore = score;
+      best = w;
+    }
+  }
+  return best ?? quota.windows[0];
+}
+function formatQuotaSummary(quota, now = Date.now(), options) {
+  const compact = options?.compact === true;
+  const planText = formatPlanLabel(quota?.plan);
+  const planName = typeof quota?.plan?.name === "string" ? quota.plan.name.trim() : "";
+  const tightest = findTightestQuotaWindow(quota, now);
+  if (!tightest) return compact ? planName || void 0 : planText;
+  const parts = [];
+  if (typeof tightest.utilization === "number") {
+    const pct = Math.round(tightest.utilization * 100);
+    parts.push(`${pct}%\u5DF2\u7528`);
+  } else if (typeof tightest.remaining === "number") {
+    if (typeof tightest.limit === "number") {
+      parts.push(`${tightest.remaining}/${tightest.limit}${tightest.unit ? ` ${tightest.unit}` : ""}`);
+    } else {
+      parts.push(`\u4F59${tightest.remaining}${tightest.unit ? ` ${tightest.unit}` : ""}`);
+    }
+  }
+  if (compact) {
+    const head = parts.length > 0 ? parts[0] : void 0;
+    return [planName || void 0, head].filter(Boolean).join(" \xB7 ") || void 0;
+  }
+  if (tightest.scope && tightest.scope !== "user" && tightest.scope !== "project" && tightest.scope !== tightest.unit) {
+    parts.push(tightest.scope);
+  }
+  if (typeof tightest.resetAt === "number" && tightest.resetAt > now) {
+    const diffSec = Math.round((tightest.resetAt - now) / 1e3);
+    if (diffSec < 60) {
+      parts.push(`${diffSec}s\u540E\u91CD\u7F6E`);
+    } else if (diffSec < 3600) {
+      parts.push(`${Math.round(diffSec / 60)}m\u540E\u91CD\u7F6E`);
+    } else if (diffSec < 86400) {
+      const hours = (diffSec / 3600).toFixed(1).replace(/\.0$/, "");
+      parts.push(`${hours}h\u540E\u91CD\u7F6E`);
+    } else {
+      const days = (diffSec / 86400).toFixed(1).replace(/\.0$/, "");
+      parts.push(`${days}d\u540E\u91CD\u7F6E`);
+    }
+  }
+  const onlyScope = parts.length === 0 || parts.length === 1 && parts[0] === tightest.scope;
+  if (onlyScope) return planText;
+  return [planText, ...parts].filter(Boolean).join(" \xB7 ");
+}
+function formatPlanLabel(plan) {
+  const name = typeof plan?.name === "string" ? plan.name.trim() : "";
+  if (!name) return void 0;
+  const credits = typeof plan?.monthlyCreditsUsd === "number" && Number.isFinite(plan.monthlyCreditsUsd) && plan.monthlyCreditsUsd > 0 ? `\u6708\u5EA6\u989D\u5EA6 $${plan.monthlyCreditsUsd}` : void 0;
+  return [`${name} \u5957\u9910`, credits].filter(Boolean).join(" \xB7 ");
+}
+
 // packages/ai/agent/agentAvailabilityShared.ts
 var DEFAULT_PROVIDER_RETRY_MS = 5 * 60 * 1e3;
 var THIN_RATE_LIMIT_COOLDOWN_MS = 60 * 1e3;
@@ -110,7 +189,8 @@ function shouldClearCooldownFromQuota(entry, quota, now, options) {
   );
   const subscriptionWindows = relevantWindows.filter(isSubscriptionPeriodWindow);
   if (subscriptionWindows.length === 0) return false;
-  if (relevantWindows.some((window) => !isSubscriptionPeriodWindow(window) && isExhaustedWindow(window))) return false;
+  if (relevantWindows.some(isExhaustedWindow)) return false;
+  if (subscriptionWindows.some((window) => isQuotaWindowExpired(window, now))) return false;
   return subscriptionWindows.every((window) => {
     const hasUtilization = typeof window.utilization === "number";
     const hasRemaining = typeof window.remaining === "number";
@@ -194,6 +274,12 @@ function resolveAgentAvailability(agent, now = Date.now()) {
       reason: "stale_quota_snapshot"
     };
   }
+  if (!relevantWindows.some((window) => !isQuotaWindowExpired(window, now))) {
+    return {
+      status: "unverified",
+      reason: "quota_window_reset"
+    };
+  }
   return {
     status: "available",
     reason: "quota_ok"
@@ -573,6 +659,7 @@ function classifyFailureSubclass(input, now = Date.now()) {
 export {
   QUOTA_ERROR_PATTERNS,
   isQuotaExhaustedError,
+  formatQuotaSummary,
   DEFAULT_PROVIDER_RETRY_MS,
   shouldClearCooldownFromQuota,
   isAgentUnavailableNow,

package/{chunk-YF4ZRVP3.js → chunk-HXHPAEAN.js}

@@ -1,6 +1,6 @@
 import {
   trimTrailingSlash
-} from "./chunk-WPOKOKZA.js";
+} from "./chunk-EPRYABUO.js";
 import {
   commandCodeModels,
   kimiCodeModels,

package/{chunk-7DQSP7JU.js → chunk-J5JTMQIA.js}

@@ -4,7 +4,7 @@ import {
 
 // packages/cli/agentCommandSupport.ts
 async function getDefaultCliDb() {
-  const { getDefaultCliLocalRuntimeDb } = await import("./localRuntimeDb-SDYFAEKA.js");
+  const { getDefaultCliLocalRuntimeDb } = await import("./localRuntimeDb-VBIMCWUC.js");
   return getDefaultCliLocalRuntimeDb();
 }
 function createNullCliDb() {

package/{chunk-EVG6HQQ7.js → chunk-JBOUVTZX.js}

@@ -15,10 +15,10 @@ import {
 } from "./chunk-4O22PGNQ.js";
 import {
   scheduleWindowsSelfUpdate
-} from "./chunk-7T5TLIY4.js";
+} from "./chunk-LKDF3ATR.js";
 import {
   t
-} from "./chunk-PPCUXO3E.js";
+} from "./chunk-3RQVYR4B.js";
 
 // packages/cli/updateCommands.ts
 import { existsSync, readFileSync, accessSync, constants } from "node:fs";

package/{chunk-D3DGBEYY.js → chunk-JUNMZOX6.js}

@@ -1,12 +1,12 @@
 import {
   requireTokenUser
-} from "./chunk-4NWJ3Z3G.js";
+} from "./chunk-RIGJPEBW.js";
 import {
   resolveServerUrl
 } from "./chunk-WACI5I6V.js";
 import {
   t
-} from "./chunk-PPCUXO3E.js";
+} from "./chunk-3RQVYR4B.js";
 
 // packages/cli/cliApiClient.ts
 var CliApiError = class extends Error {

package/{chunk-7T5TLIY4.js → chunk-LKDF3ATR.js}

@@ -1,6 +1,6 @@
 import {
   t
-} from "./chunk-PPCUXO3E.js";
+} from "./chunk-3RQVYR4B.js";
 
 // packages/cli/windowsSelfUpdate.ts
 import { spawn } from "node:child_process";

package/{chunk-LEJSZV6V.js → chunk-P2ZLUIW2.js}

@@ -1,8 +1,9 @@
 import {
+  Level,
   createLegacyServerDb,
   createLevelAuthorityStore,
   isLevelLockError
-} from "./chunk-AWVFQMOV.js";
+} from "./chunk-ZYKJBRZ3.js";
 import {
   createCliAuthorityBrokerClient,
   createCliAuthorityBrokerSocketInvoker,
@@ -21,13 +22,188 @@ import {
 } from "./chunk-HNMXYYJR.js";
 
 // packages/cli/localRuntimeAuthority.ts
-import fs2 from "node:fs";
-import path2 from "node:path";
+import fs4 from "node:fs";
+import path4 from "node:path";
 
 // packages/database-engine/cliAuthorityBrokerServer.ts
+import fs3 from "node:fs";
+import path3 from "node:path";
+import { createServer } from "node:net";
+
+// packages/database-engine/levelDbCorruptionRecovery.ts
 import fs from "node:fs";
 import path from "node:path";
-import { createServer } from "node:net";
+var CORRUPTION_CODE = "LEVEL_CORRUPTION";
+var CORRUPTION_MESSAGE = /Corruption:|missing files/i;
+var levelClassWithRepair = Level;
+function isLevelCorruptionError(error) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = error;
+  while (current && !seen.has(current)) {
+    seen.add(current);
+    if (current.code === CORRUPTION_CODE) return true;
+    if (CORRUPTION_MESSAGE.test(toErrorMessage(current))) return true;
+    current = current.cause;
+  }
+  return false;
+}
+function formatUtcStamp(now) {
+  return new Date(now).toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "").replace("T", "-");
+}
+function resolveBackupPath(dbPath, now) {
+  const base = `${dbPath}.corrupt-${formatUtcStamp(now)}`;
+  let candidate = base;
+  for (let index = 2; fs.existsSync(candidate); index += 1) {
+    candidate = `${base}-${index}`;
+  }
+  return candidate;
+}
+async function repairLevelDatabase(dbPath) {
+  await levelClassWithRepair.repair(dbPath);
+}
+async function recoverCorruptedLevelDb(options) {
+  const { dbPath } = options;
+  const log = options.log ?? ((message) => console.warn(message));
+  const repair = options.repair ?? repairLevelDatabase;
+  const backupPath = resolveBackupPath(dbPath, (options.now ?? Date.now)());
+  fs.renameSync(dbPath, backupPath);
+  try {
+    fs.cpSync(backupPath, dbPath, { recursive: true, preserveTimestamps: true });
+    await repair(dbPath);
+  } catch (error) {
+    try {
+      fs.rmSync(dbPath, { recursive: true, force: true });
+      fs.renameSync(backupPath, dbPath);
+    } catch (rollbackError) {
+      throw Object.assign(
+        new Error(
+          `Failed to repair the local database at ${dbPath} and could not restore the original. The untouched copy is at ${backupPath}; stop every Nolo process before retrying. Do not delete ${path.join(dbPath, "LOCK")} and do not reinstall Nolo: ${toErrorMessage(error)}`,
+          { cause: new AggregateError([error, rollbackError], "LevelDB repair and rollback both failed") }
+        ),
+        { code: CORRUPTION_CODE, backupPath }
+      );
+    }
+    throw Object.assign(
+      new Error(
+        `Failed to repair the local database at ${dbPath}; the original database was restored unchanged. Stop every Nolo process and run the CLI again. Do not delete ${path.join(dbPath, "LOCK")} and do not reinstall Nolo: ${toErrorMessage(error)}`,
+        { cause: error }
+      ),
+      { code: CORRUPTION_CODE, backupPath }
+    );
+  }
+  log(
+    `[nolo] local database corruption detected; preserved original at ${backupPath} and repaired a copy.`
+  );
+  return { backupPath };
+}
+
+// packages/database-engine/levelDbOwnershipLock.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
+var LOCKED_CODE = "LEVEL_LOCKED";
+var UNWRITTEN_LOCK_GRACE_MS = 5e3;
+function createLockError(lockPath, ownerPid) {
+  const detail = ownerPid === void 0 ? `the lock file ${lockPath} exists but its owner process is unknown` : `it is held by process ${ownerPid}`;
+  return Object.assign(
+    new Error(
+      `CLI authority database is already open by another process: ${detail} (${lockPath}). Wait for that process to exit, or stop it before starting Nolo again.`
+    ),
+    { code: LOCKED_CODE, lockPath, ownerPid }
+  );
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function readLockHolder(lockPath) {
+  let raw;
+  try {
+    raw = fs2.readFileSync(lockPath, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+  let pid;
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.pid === "number" && Number.isInteger(parsed.pid) && parsed.pid > 0) {
+      pid = parsed.pid;
+    }
+  } catch {
+  }
+  let mtimeMs = Date.now();
+  try {
+    mtimeMs = fs2.statSync(lockPath).mtimeMs;
+  } catch {
+  }
+  return { pid, mtimeMs };
+}
+function acquireLevelDbOwnershipLock(dbPath) {
+  const lockPath = `${dbPath}.owner`;
+  fs2.mkdirSync(path2.dirname(lockPath), { recursive: true });
+  const content = `${JSON.stringify({ pid: process.pid, startedAt: (/* @__PURE__ */ new Date()).toISOString() })}
+`;
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    let fd;
+    try {
+      fd = fs2.openSync(lockPath, "wx", 420);
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      const holder = readLockHolder(lockPath);
+      if (!holder) continue;
+      if (holder.pid !== void 0 && isProcessAlive(holder.pid)) {
+        throw createLockError(lockPath, holder.pid);
+      }
+      if (holder.pid === void 0 && Date.now() - holder.mtimeMs < UNWRITTEN_LOCK_GRACE_MS) {
+        throw createLockError(lockPath);
+      }
+      const quarantine = `${lockPath}.stale-${process.pid}-${Date.now()}`;
+      try {
+        fs2.renameSync(lockPath, quarantine);
+        fs2.rmSync(quarantine, { force: true });
+      } catch (renameError) {
+        if (renameError.code !== "ENOENT") throw renameError;
+      }
+      continue;
+    }
+    try {
+      fs2.writeSync(fd, content);
+    } catch (error) {
+      try {
+        fs2.closeSync(fd);
+      } catch {
+      }
+      try {
+        fs2.rmSync(lockPath, { force: true });
+      } catch {
+      }
+      throw error;
+    }
+    let released = false;
+    return {
+      lockPath,
+      release() {
+        if (released) return;
+        released = true;
+        try {
+          fs2.closeSync(fd);
+        } catch {
+        }
+        try {
+          fs2.rmSync(lockPath, { force: true });
+        } catch {
+        }
+      }
+    };
+  }
+  throw createLockError(lockPath);
+}
+
+// packages/database-engine/cliAuthorityBrokerServer.ts
 var brokerRegistry = /* @__PURE__ */ new Map();
 var databaseOwners = /* @__PURE__ */ new Map();
 var DEFAULT_ITERATOR_LIMIT = 200;
@@ -57,18 +233,18 @@ function buildListeningEndpoint(server, target) {
   return `tcp://${target.host}:${info.port}`;
 }
 function ensureParentDir(filePath) {
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs3.mkdirSync(path3.dirname(filePath), { recursive: true });
 }
 function writeJsonFile(filePath, data) {
   if (!filePath) return;
   ensureParentDir(filePath);
-  fs.writeFileSync(filePath, `${JSON.stringify(data, null, 2)}
+  fs3.writeFileSync(filePath, `${JSON.stringify(data, null, 2)}
 `, "utf8");
 }
 function removeFileIfPresent(filePath) {
   if (!filePath) return;
   try {
-    fs.rmSync(filePath, { force: true });
+    fs3.rmSync(filePath, { force: true });
   } catch {
   }
 }
@@ -140,10 +316,55 @@ async function dispatchCliAuthorityBrokerRequest(store, request) {
     return createErrorResponse(error);
   }
 }
+async function openAuthorityStoreWithCorruptionRecovery(options, track) {
+  let attemptStore;
+  try {
+    attemptStore = await options.createStore();
+    track(attemptStore);
+    await attemptStore.open();
+    return attemptStore;
+  } catch (error) {
+    if (!options.dbPath || !isLevelCorruptionError(error)) throw error;
+    if (attemptStore) {
+      try {
+        await attemptStore.close();
+      } catch (closeError) {
+        throw Object.assign(
+          new Error(
+            `LevelDB corruption detected at ${options.dbPath}, but the failed database handle could not be closed; on-disk files were left untouched. Stop every Nolo process and retry: ${toErrorMessage(closeError)}`,
+            { cause: closeError }
+          ),
+          { code: "LEVEL_CORRUPTION" }
+        );
+      }
+      track(void 0);
+      attemptStore = void 0;
+    }
+    const { backupPath } = await recoverCorruptedLevelDb({
+      dbPath: options.dbPath,
+      now: options.now
+    });
+    try {
+      attemptStore = await options.createStore();
+      track(attemptStore);
+      await attemptStore.open();
+      return attemptStore;
+    } catch (retryError) {
+      throw Object.assign(
+        new Error(
+          `Local database corruption at ${options.dbPath} was preserved at ${backupPath}, but reopening the repaired copy failed: ${toErrorMessage(retryError)}. Do not reinstall Nolo and do not delete ${path3.join(options.dbPath, "LOCK")}; the preserved original database is at ${backupPath}.`,
+          { cause: retryError }
+        ),
+        { code: "LEVEL_CORRUPTION", backupPath }
+      );
+    }
+  }
+}
 async function createBrokerHandle(options) {
   const target = resolveBrokerListenTarget(options.endpoint);
   const socketMode = (options.transportMode ?? "socket") === "socket";
   let store;
+  let ownershipLock;
   const sockets = /* @__PURE__ */ new Set();
   const server = createServer((socket) => {
     sockets.add(socket);
@@ -174,8 +395,12 @@ async function createBrokerHandle(options) {
       });
       server.unref();
     }
-    store = await options.createStore();
-    await store.open();
+    if (options.dbPath) {
+      ownershipLock = acquireLevelDbOwnershipLock(options.dbPath);
+    }
+    store = await openAuthorityStoreWithCorruptionRecovery(options, (created) => {
+      store = created;
+    });
     storeReady = true;
     const readyStore = store;
     const now = options.now ?? Date.now;
@@ -212,6 +437,8 @@ async function createBrokerHandle(options) {
           await readyStore.close();
           brokerRegistry.delete(options.endpoint);
           releaseDatabaseOwnership(options);
+          ownershipLock?.release();
+          ownershipLock = void 0;
           removeFileIfPresent(options.metadataPath);
           removeFileIfPresent(options.healthPath);
         })().catch((error) => {
@@ -234,6 +461,7 @@ async function createBrokerHandle(options) {
         throw Object.assign(new AggregateError([error, closeError], "Broker startup failed and the native authority store could not close"), { retainAuthorityOwnership: true });
       }
     }
+    ownershipLock?.release();
     throw error;
   }
 }
@@ -259,14 +487,14 @@ function bindSocketRequestHandler(args) {
   });
 }
 function canonicalDatabasePath(dbPath) {
-  const absolute = path.resolve(dbPath);
+  const absolute = path3.resolve(dbPath);
   try {
-    return fs.realpathSync(absolute);
+    return fs3.realpathSync(absolute);
   } catch (error) {
     if (error.code !== "ENOENT") throw error;
-    const parent = path.dirname(absolute);
+    const parent = path3.dirname(absolute);
     if (parent === absolute) throw error;
-    return path.join(canonicalDatabasePath(parent), path.basename(absolute));
+    return path3.join(canonicalDatabasePath(parent), path3.basename(absolute));
   }
 }
 function releaseDatabaseOwnership(options) {
@@ -302,7 +530,7 @@ function getOrCreateCliAuthorityBrokerServer(options) {
 
 // packages/cli/localRuntimeAuthority.ts
 function ensureDbParentDir(dbPath) {
-  fs2.mkdirSync(path2.dirname(dbPath), { recursive: true });
+  fs4.mkdirSync(path4.dirname(dbPath), { recursive: true });
 }
 function findCliAuthorityCorruption(error) {
   const seen = /* @__PURE__ */ new Set();
@@ -336,7 +564,7 @@ async function sleep(ms) {
   await new Promise((resolve) => setTimeout(resolve, ms));
 }
 function resolveCliLocalRuntimeDbPath(options = {}) {
-  return path2.join(
+  return path4.join(
     resolveNoloHome({
       env: options.env,
       homeDir: options.homeDir

package/{chunk-PK5TD4ST.js → chunk-PQTOTGMI.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-XPHZK3PJ.js";
 import {
   resolvePlatformAuthToken
-} from "./chunk-WPOKOKZA.js";
+} from "./chunk-EPRYABUO.js";
 import {
   isRecord
 } from "./chunk-KUG52IAP.js";