@qwen-code/qwen-code 0.21.0 → 0.21.1-nightly.20260731.702932cc7

package/chunks/chunk-45UYUCJ6.js

@@ -0,0 +1,363 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  getPlugin
+} from "./chunk-KWHKHSIS.js";
+import {
+  loadSettings,
+  saveSettings
+} from "./chunk-A5T5W7PR.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/serve/channel-settings-store.ts
+init_esbuild_shims();
+import { createHash } from "node:crypto";
+import { isDeepStrictEqual } from "node:util";
+var ChannelSettingsError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "ChannelSettingsError";
+  }
+  static {
+    __name(this, "ChannelSettingsError");
+  }
+};
+function revisionOf(channels, startupNames) {
+  return createHash("sha256").update(JSON.stringify({ channels, startupNames })).digest("hex");
+}
+__name(revisionOf, "revisionOf");
+function applySecretUpdate(current, update) {
+  validateSecretUpdate(update);
+  if (update.operation === "preserve") return current;
+  if (update.operation === "clear") return void 0;
+  if (typeof update.value !== "string" || update.value.length === 0) {
+    throw invalidSecret("Secret replacements must be non-empty strings.");
+  }
+  return update.value;
+}
+__name(applySecretUpdate, "applySecretUpdate");
+function invalidSecret(message) {
+  return new ChannelSettingsError("channel_settings_invalid_secret", message);
+}
+__name(invalidSecret, "invalidSecret");
+function invalidConfig(message) {
+  return new ChannelSettingsError("channel_settings_invalid_config", message);
+}
+__name(invalidConfig, "invalidConfig");
+var UNSAFE_OBJECT_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function assertSafeChannelName(name) {
+  if (UNSAFE_OBJECT_KEYS.has(name)) {
+    throw new ChannelSettingsError(
+      "channel_settings_invalid_name",
+      `Channel name ${JSON.stringify(name)} is not allowed.`
+    );
+  }
+}
+__name(assertSafeChannelName, "assertSafeChannelName");
+function assertUpsertChannelName(name) {
+  assertSafeChannelName(name);
+  if (isAllStartupName(name)) {
+    throw new ChannelSettingsError(
+      "channel_settings_invalid_name",
+      `Channel name ${JSON.stringify(name)} is reserved for startup selection.`
+    );
+  }
+}
+__name(assertUpsertChannelName, "assertUpsertChannelName");
+function isAllStartupName(name) {
+  return name.trim() === "all";
+}
+__name(isAllStartupName, "isAllStartupName");
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+__name(isRecord, "isRecord");
+function isEnvironmentReference(value) {
+  return /^\$[A-Za-z_][A-Za-z0-9_]*$/.test(value);
+}
+__name(isEnvironmentReference, "isEnvironmentReference");
+function assertStringRecord(key, value, allowedKeys) {
+  if (!isRecord(value)) {
+    throw invalidConfig(`Channel field "${key}" must be an object.`);
+  }
+  for (const [nestedKey, nestedValue] of Object.entries(value)) {
+    if (!allowedKeys.has(nestedKey) || typeof nestedValue !== "string") {
+      throw invalidConfig(`Channel field "${key}.${nestedKey}" is invalid.`);
+    }
+  }
+}
+__name(assertStringRecord, "assertStringRecord");
+function assertNumberRecord(key, value, allowedKeys) {
+  if (!isRecord(value)) {
+    throw invalidConfig(`Channel field "${key}" must be an object.`);
+  }
+  for (const [nestedKey, nestedValue] of Object.entries(value)) {
+    if (!allowedKeys.has(nestedKey) || typeof nestedValue !== "number" || !Number.isFinite(nestedValue)) {
+      throw invalidConfig(`Channel field "${key}.${nestedKey}" is invalid.`);
+    }
+  }
+}
+__name(assertNumberRecord, "assertNumberRecord");
+function assertSharedField(key, value) {
+  const enumValues = {
+    senderPolicy: /* @__PURE__ */ new Set(["allowlist", "pairing", "open"]),
+    dmPolicy: /* @__PURE__ */ new Set(["open", "disabled"]),
+    groupPolicy: /* @__PURE__ */ new Set(["disabled", "allowlist", "open"]),
+    sessionScope: /* @__PURE__ */ new Set(["user", "thread", "single"]),
+    dispatchMode: /* @__PURE__ */ new Set(["steer", "followup", "collect"]),
+    blockStreaming: /* @__PURE__ */ new Set(["on", "off"])
+  };
+  if (Object.hasOwn(enumValues, key)) {
+    if (typeof value !== "string" || !enumValues[key].has(value)) {
+      throw invalidConfig(`Channel field "${key}" has an invalid value.`);
+    }
+    return true;
+  }
+  if (["model", "cwd", "approvalMode", "instructions"].includes(key)) {
+    if (typeof value !== "string") {
+      throw invalidConfig(`Channel field "${key}" must be a string.`);
+    }
+    return true;
+  }
+  if (key === "allowedUsers") {
+    if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+      throw invalidConfig(`Channel field "${key}" must be a string array.`);
+    }
+    return true;
+  }
+  if (key === "groupHistoryLimit") {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+      throw invalidConfig(`Channel field "${key}" must be a number.`);
+    }
+    return true;
+  }
+  if (key === "identity") {
+    assertStringRecord(
+      key,
+      value,
+      /* @__PURE__ */ new Set(["id", "displayName", "description"])
+    );
+    return true;
+  }
+  if (key === "blockStreamingChunk") {
+    assertNumberRecord(key, value, /* @__PURE__ */ new Set(["minChars", "maxChars"]));
+    return true;
+  }
+  if (key === "blockStreamingCoalesce") {
+    assertNumberRecord(key, value, /* @__PURE__ */ new Set(["idleMs"]));
+    return true;
+  }
+  if (key === "memoryScope") {
+    if (!isRecord(value)) {
+      throw invalidConfig(`Channel field "${key}" must be an object.`);
+    }
+    for (const [nestedKey, nestedValue] of Object.entries(value)) {
+      const valid = nestedKey === "namespace" && typeof nestedValue === "string" || nestedKey === "mode" && nestedValue === "metadata-only";
+      if (!valid) {
+        throw invalidConfig(`Channel field "${key}.${nestedKey}" is invalid.`);
+      }
+    }
+    return true;
+  }
+  return false;
+}
+__name(assertSharedField, "assertSharedField");
+function assertDescriptorValue(field, value) {
+  const invalidEnvironment = typeof value === "string" && isEnvironmentReference(value) && field.envResolvable !== true;
+  if (invalidEnvironment) {
+    throw invalidConfig(
+      `Channel field "${field.key}" does not support environment references.`
+    );
+  }
+  const valid = (field.kind === "string" || field.kind === "secret") && typeof value === "string" && value.length > 0 || field.kind === "boolean" && typeof value === "boolean" || field.kind === "number" && typeof value === "number" && Number.isFinite(value) || field.kind === "enum" && typeof value === "string" && field.options?.some((option) => option.value === value) === true;
+  if (!valid) {
+    throw invalidConfig(`Channel field "${field.key}" has an invalid value.`);
+  }
+}
+__name(assertDescriptorValue, "assertDescriptorValue");
+function assertManagedConfig(config, previous, fields) {
+  const descriptorFields = new Map(fields.map((field) => [field.key, field]));
+  for (const [key, value] of Object.entries(config)) {
+    if (key === "type") continue;
+    const field = descriptorFields.get(key);
+    if (field) {
+      assertDescriptorValue(field, value);
+      continue;
+    }
+    if (assertSharedField(key, value)) continue;
+    if (!Object.hasOwn(previous, key) || !isDeepStrictEqual(previous[key], value)) {
+      throw invalidConfig(`Channel field "${key}" is not manageable.`);
+    }
+  }
+  for (const field of fields) {
+    if (!field.required) continue;
+    const value = config[field.key];
+    if (value === void 0 || value === null || value === "") {
+      throw invalidConfig(`Channel field "${field.key}" is required.`);
+    }
+  }
+}
+__name(assertManagedConfig, "assertManagedConfig");
+function validateSecretUpdate(update) {
+  if (!isRecord(update)) {
+    throw invalidSecret("Secret updates must be objects.");
+  }
+  const operation = update["operation"];
+  const keys = Object.keys(update).sort();
+  const valid = (operation === "preserve" || operation === "clear") && keys.length === 1 && keys[0] === "operation" || operation === "replace" && keys.length === 2 && keys[0] === "operation" && keys[1] === "value" && typeof update["value"] === "string" && update["value"].length > 0;
+  if (!valid) {
+    throw invalidSecret("Secret updates contain an invalid operation.");
+  }
+}
+__name(validateSecretUpdate, "validateSecretUpdate");
+function assertValidChannelSecretUpdates(updates) {
+  if (!isRecord(updates)) {
+    throw invalidSecret("Secret updates must be objects.");
+  }
+  for (const [key, update] of Object.entries(updates)) {
+    if (UNSAFE_OBJECT_KEYS.has(key)) {
+      throw invalidSecret(`Secret update ${JSON.stringify(key)} is invalid.`);
+    }
+    validateSecretUpdate(update);
+  }
+}
+__name(assertValidChannelSecretUpdates, "assertValidChannelSecretUpdates");
+function workspaceValues(workspaceCwd) {
+  const settings = loadSettings(workspaceCwd, { skipLoadEnvironment: true }).workspace.settings;
+  const rawChannels = isRecord(settings.channels) ? settings.channels : {};
+  const channels = {};
+  for (const [name, config] of Object.entries(rawChannels)) {
+    if (isRecord(config)) channels[name] = config;
+  }
+  const startupNames = Array.isArray(settings.serve?.channels) ? settings.serve.channels.filter(
+    (name) => typeof name === "string"
+  ) : [];
+  return { channels, startupNames };
+}
+__name(workspaceValues, "workspaceValues");
+var WorkspaceChannelSettingsStore = class {
+  constructor(workspaceCwd) {
+    this.workspaceCwd = workspaceCwd;
+  }
+  static {
+    __name(this, "WorkspaceChannelSettingsStore");
+  }
+  snapshot() {
+    const { channels, startupNames } = workspaceValues(this.workspaceCwd);
+    return {
+      revision: revisionOf(channels, startupNames),
+      channels: { ...channels },
+      startupNames: [...startupNames]
+    };
+  }
+  async upsert(name, options) {
+    assertUpsertChannelName(name);
+    const secretUpdates = options.secrets === void 0 ? {} : options.secrets;
+    assertValidChannelSecretUpdates(secretUpdates);
+    const plugin = await getPlugin(options.config.type);
+    if (!plugin?.management) {
+      throw new ChannelSettingsError(
+        "channel_settings_unmanageable",
+        `Channel type "${options.config.type}" does not provide safe management metadata.`
+      );
+    }
+    const secretKeys = new Set(
+      plugin.management.fields.filter((field) => field.kind === "secret").map((field) => field.key)
+    );
+    for (const key of Object.keys(secretUpdates)) {
+      if (!secretKeys.has(key)) {
+        throw invalidSecret(
+          `Channel type "${options.config.type}" does not declare "${key}" as a secret.`
+        );
+      }
+    }
+    for (const key of secretKeys) {
+      if (Object.hasOwn(options.config, key)) {
+        throw invalidSecret(
+          `Secret "${key}" must use an explicit preserve, replace, or clear operation.`
+        );
+      }
+    }
+    const current = this.assertRevision(options.expectedRevision);
+    const storedPrevious = current.channels[name] ?? {};
+    const previous = storedPrevious["type"] === options.config.type ? storedPrevious : {};
+    const nextConfig = { ...options.config };
+    for (const key of secretKeys) {
+      const update = secretUpdates[key] ?? { operation: "preserve" };
+      const value = applySecretUpdate(previous[key], update);
+      if (value !== void 0) nextConfig[key] = value;
+    }
+    assertManagedConfig(nextConfig, previous, plugin.management.fields);
+    const channels = { ...current.channels, [name]: nextConfig };
+    const workspaceFile = loadSettings(this.workspaceCwd, {
+      skipLoadEnvironment: true
+    }).workspace;
+    saveSettings(workspaceFile, { channels }, ["channels"], {
+      throwOnWriteFailure: true
+    });
+    return this.snapshot();
+  }
+  async remove(name, options) {
+    assertSafeChannelName(name);
+    const current = this.assertRevision(options.expectedRevision);
+    const channels = { ...current.channels };
+    delete channels[name];
+    const hasAllSentinel = current.startupNames.some(isAllStartupName);
+    const startupNames = hasAllSentinel ? Object.keys(channels).some(
+      (channelName) => !isAllStartupName(channelName)
+    ) ? ["all"] : [] : current.startupNames.filter((startupName) => startupName !== name);
+    const workspaceFile = loadSettings(this.workspaceCwd, {
+      skipLoadEnvironment: true
+    }).workspace;
+    saveSettings(
+      workspaceFile,
+      { channels, serve: { channels: startupNames } },
+      ["channels"],
+      { throwOnWriteFailure: true }
+    );
+    return this.snapshot();
+  }
+  async setStartupNames(names, options) {
+    for (const name of names) {
+      assertSafeChannelName(name);
+    }
+    this.assertRevision(options.expectedRevision);
+    const workspaceFile = loadSettings(this.workspaceCwd, {
+      skipLoadEnvironment: true
+    }).workspace;
+    saveSettings(
+      workspaceFile,
+      { serve: { channels: [...names] } },
+      ["serve", "channels"],
+      { throwOnWriteFailure: true }
+    );
+    return this.snapshot();
+  }
+  assertRevision(expectedRevision) {
+    const current = this.snapshot();
+    if (current.revision !== expectedRevision) {
+      throw new ChannelSettingsError(
+        "channel_settings_conflict",
+        "Channel settings changed; reload before trying again."
+      );
+    }
+    return current;
+  }
+};
+
+export {
+  ChannelSettingsError,
+  assertValidChannelSecretUpdates,
+  WorkspaceChannelSettingsStore
+};
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-JZA3JUDJ.js → chunk-4KP2F2TE.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   createDebugLogger
-} from "./chunk-NL7LTRLR.js";
+} from "./chunk-E2BHWIDT.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-IO3IX5Q4.js → chunk-4YJQD2IO.js}

@@ -6,7 +6,7 @@ import {
   getNestedProperty,
   getPersistScopeForModelSelection,
   restoreSettingsFromBackup
-} from "./chunk-TEHGS6UP.js";
+} from "./chunk-A5T5W7PR.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-JXJFVC6E.js → chunk-5G6XUGXO.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   theme
-} from "./chunk-VAK25FTU.js";
+} from "./chunk-45IOTAUS.js";
 import {
   require_jsx_runtime
 } from "./chunk-SV5PQVQE.js";
@@ -10,14 +10,14 @@ import {
   Box_default,
   Text,
   use_is_screen_reader_enabled_default
-} from "./chunk-6GMVPFB2.js";
+} from "./chunk-2IIJTXYF.js";
 import {
   require_react
 } from "./chunk-5QWWOFGG.js";
 import {
   formatHistoryGapNotice,
   indexGapsByChild
-} from "./chunk-WCXCRJYB.js";
+} from "./chunk-Z3YLHKB7.js";
 import {
   stringWidth
 } from "./chunk-2MIN6GRR.js";
@@ -29,16 +29,17 @@ import {
 } from "./chunk-E5Z2AVNV.js";
 import {
   t
-} from "./chunk-LKEJ26GS.js";
+} from "./chunk-B3TA3IF5.js";
 import {
-  getToolResponseDisplayText
-} from "./chunk-PHOF65IG.js";
+  getToolResponseDisplayText,
+  stripTrailingUserPromptSubmitContextPart
+} from "./chunk-FRXG4ARO.js";
 import {
   stripAnsi
 } from "./chunk-TWPJO254.js";
 import {
   ToolDisplayNames
-} from "./chunk-PR75REBZ.js";
+} from "./chunk-MM7TH7ZM.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -2741,6 +2742,16 @@ function safeDescription(raw) {
   return cleaned || void 0;
 }
 __name(safeDescription, "safeDescription");
+function categoryShowsDescriptionsInline(toolCalls, category) {
+  const sameCategory = toolCalls.filter(
+    (tc) => getToolCategory(tc.name) === category
+  );
+  if (sameCategory.length > DESCRIPTION_INLINE_LIMIT) return false;
+  return sameCategory.every(
+    (tc) => safeDescription(tc.description) !== void 0
+  );
+}
+__name(categoryShowsDescriptionsInline, "categoryShowsDescriptionsInline");
 function getActiveToolHint(toolCalls) {
   if (toolCalls.length < 2) return void 0;
   const statuses = [
@@ -2753,16 +2764,21 @@ function getActiveToolHint(toolCalls) {
       const tool = toolCalls[index];
       if (tool.status === status) {
         const category = getToolCategory(tool.name);
-        const usesCountSummary = toolCalls.some(
+        const hasCategoryPeers = toolCalls.some(
           (candidate, candidateIndex) => candidateIndex !== index && getToolCategory(candidate.name) === category
         );
-        return usesCountSummary ? safeDescription(tool.description) : void 0;
+        if (!hasCategoryPeers) return void 0;
+        if (categoryShowsDescriptionsInline(toolCalls, category))
+          return void 0;
+        return safeDescription(tool.description);
       }
     }
   }
   return void 0;
 }
 __name(getActiveToolHint, "getActiveToolHint");
+var DESCRIPTION_INLINE_LIMIT = 3;
+var DESCRIPTION_PREVIEW_COUNT = 2;
 function buildToolSummary(toolCalls, isActive) {
   if (toolCalls.length === 0) return "";
   const toolsByCategory = /* @__PURE__ */ new Map();
@@ -2777,20 +2793,37 @@ function buildToolSummary(toolCalls, isActive) {
     const tools = toolsByCategory.get(cat);
     if (!tools || tools.length === 0) continue;
     const template = CATEGORY_TEMPLATES[cat];
+    const verb = isActive ? template.activeVerb : template.pastVerb;
     let part;
     if (tools.length === 1) {
       const safeDesc = safeDescription(tools[0].description);
       if (safeDesc !== void 0) {
-        const verb = isActive ? template.activeVerb : template.pastVerb;
         part = `${verb} ${safeDesc}`;
       } else {
         part = t(isActive ? template.active.one : template.past.one, {
           count: "1"
         });
       }
+    } else if (tools.length <= DESCRIPTION_INLINE_LIMIT) {
+      const descriptions = tools.map((tc) => safeDescription(tc.description)).filter((d) => d !== void 0);
+      if (descriptions.length === tools.length) {
+        part = `${verb} ${descriptions.join(", ")}`;
+      } else {
+        const forms = isActive ? template.active : template.past;
+        part = t(forms.many, { count: String(tools.length) });
+      }
     } else {
-      const forms = isActive ? template.active : template.past;
-      part = t(forms.many, { count: String(tools.length) });
+      const previewDescs = tools.slice(0, DESCRIPTION_PREVIEW_COUNT).map((tc) => safeDescription(tc.description)).filter((d) => d !== void 0);
+      if (previewDescs.length === DESCRIPTION_PREVIEW_COUNT) {
+        const remaining = tools.length - DESCRIPTION_PREVIEW_COUNT;
+        const morePhrase = t("... and {{count}} more", {
+          count: String(remaining)
+        });
+        part = `${verb} ${previewDescs.join(", ")}, ${morePhrase}`;
+      } else {
+        const forms = isActive ? template.active : template.past;
+        part = t(forms.many, { count: String(tools.length) });
+      }
     }
     if (parts.length > 0) {
       part = part.charAt(0).toLowerCase() + part.slice(1);
@@ -2848,6 +2881,17 @@ var CompactToolGroupDisplay = /* @__PURE__ */ __name(({ toolCalls, contentWidth
 }, "CompactToolGroupDisplay");
 
 // packages/cli/src/ui/utils/resumeHistoryUtils.ts
+function extractUserRecordDisplayText(record) {
+  const payload = record.systemPayload;
+  if (payload?.displayText) {
+    return payload.displayText;
+  }
+  const parts = record.message?.parts ?? [];
+  return extractTextFromParts([
+    ...stripTrailingUserPromptSubmitContextPart(parts)
+  ]);
+}
+__name(extractUserRecordDisplayText, "extractUserRecordDisplayText");
 function extractTextFromParts(parts) {
   if (!parts) return "";
   const textParts = [];
@@ -3053,7 +3097,7 @@ function convertToHistoryItems(conversation, config, historyGaps) {
             currentToolGroup = [];
           }
           const payload = pendingAtCommands.shift();
-          const text2 = payload.userText || extractTextFromParts(record.message?.parts);
+          const text2 = payload.userText || extractUserRecordDisplayText(record);
           if (text2) {
             items.push({ type: "user", text: text2 });
           }
@@ -3073,7 +3117,7 @@ function convertToHistoryItems(conversation, config, historyGaps) {
           });
           currentToolGroup = [];
         }
-        const text = extractTextFromParts(record.message?.parts);
+        const text = extractUserRecordDisplayText(record);
         if (text) {
           items.push({ type: "user", text });
         }
@@ -3130,6 +3174,9 @@ function convertToHistoryItems(conversation, config, historyGaps) {
           if (toolCall) {
             const rawDisplay = record.toolCallResult.resultDisplay;
             toolCall.resultDisplay = rawDisplay;
+            if (record.toolCallResult.visionBridgeNotice !== void 0) {
+              toolCall.visionBridgeNotice = record.toolCallResult.visionBridgeNotice;
+            }
             const rawStatus = record.toolCallResult["status"];
             toolCall.status = rawStatus === "error" ? "Error" /* Error */ : "Success" /* Success */;
             if (toolCall.status === "Success" /* Success */ && isCollapsibleTool(toolCall.name)) {

package/chunks/{chunk-ZOIFNCKL.js → chunk-5NNHICSA.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   getInboxesDir
-} from "./chunk-PWTZEM3C.js";
+} from "./chunk-JXVC2PL3.js";
 import {
   require_proper_lockfile
 } from "./chunk-KRXPRVGL.js";
@@ -11,11 +11,11 @@ import {
 } from "./chunk-VGC4I5JJ.js";
 import {
   atomicWriteJSON
-} from "./chunk-A5L3JMUA.js";
+} from "./chunk-HC45LTEN.js";
 import {
   createDebugLogger,
   isNodeError
-} from "./chunk-NL7LTRLR.js";
+} from "./chunk-E2BHWIDT.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -27,14 +27,6 @@ import {
 // packages/core/src/agents/team/leaderPermissionBridge.ts
 init_esbuild_shims();
 var leaderCallbacks = null;
-function registerLeader(callbacks) {
-  leaderCallbacks = callbacks;
-}
-__name(registerLeader, "registerLeader");
-function getLeader() {
-  return leaderCallbacks;
-}
-__name(getLeader, "getLeader");
 function unregisterLeader() {
   leaderCallbacks = null;
 }
@@ -167,15 +159,6 @@ async function consumeUnread(teamName, agentName, type) {
   });
 }
 __name(consumeUnread, "consumeUnread");
-async function clearInbox(teamName, agentName) {
-  const inboxPath = getInboxPath(teamName, agentName);
-  try {
-    await fs.unlink(inboxPath);
-  } catch (err) {
-    if (!isNodeError(err) || err.code !== "ENOENT") throw err;
-  }
-}
-__name(clearInbox, "clearInbox");
 async function clearAllInboxes(teamName) {
   const dir = getInboxesDir(teamName);
   await fs.rm(dir, { recursive: true, force: true });
@@ -224,8 +207,6 @@ async function readInboxRaw(inboxPath) {
 __name(readInboxRaw, "readInboxRaw");
 
 export {
-  registerLeader,
-  getLeader,
   unregisterLeader,
   forwardApproval,
   wrapConfirmWithBadge,
@@ -234,7 +215,6 @@ export {
   readInbox,
   writeMessage,
   consumeUnread,
-  clearInbox,
   clearAllInboxes,
   sendStructuredMessage
 };

package/chunks/{chunk-A4UCTEB5.js → chunk-5WV5S2GT.js}

@@ -3513,7 +3513,6 @@ var require_streams = __commonJS({
 // node_modules/iconv-lite/lib/index.js
 var require_lib = __commonJS({
   "node_modules/iconv-lite/lib/index.js"(exports, module) {
-    "use strict";
     init_esbuild_shims();
     var Buffer = require_safer().Buffer;
     var bomHandling = require_bom_handling();

package/chunks/{chunk-RHLZR4E5.js → chunk-675H6PLP.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   atomicWriteFileSync
-} from "./chunk-A5L3JMUA.js";
+} from "./chunk-HC45LTEN.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";