@qwen-code/qwen-code 0.21.0 → 0.21.1

package/chunks/chunk-OCPBI7J5.js

@@ -0,0 +1,18 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+
+// packages/acp-bridge/src/mcpTimeouts.ts
+init_esbuild_shims();
+var MCP_RESTART_SERVER_DEADLINE_MS = 3e5;
+
+export {
+  MCP_RESTART_SERVER_DEADLINE_MS
+};
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-E5TUC6CA.js → chunk-OKF7JF3R.js}

@@ -2,13 +2,13 @@
 "use strict";
 import {
   isPrivateHost
-} from "./chunk-NH6KE4JX.js";
+} from "./chunk-LW3RFMG7.js";
 import {
   loadUndici
-} from "./chunk-2JZBVYTU.js";
+} from "./chunk-WZRWHXFE.js";
 import {
   getErrorMessage
-} from "./chunk-NL7LTRLR.js";
+} from "./chunk-UHUSJ6X7.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-TGILQ3YH.js → chunk-P4WOAOJW.js}

@@ -2,12 +2,12 @@
 "use strict";
 import {
   buildPermissionSettings
-} from "./chunk-VRYUBFMC.js";
+} from "./chunk-MR5EAQ5M.js";
 import {
   resolveVoiceStreamConfig,
   resolveVoiceTranscriptionConfig,
   transcribeVoiceAudio
-} from "./chunk-H4SBPHSA.js";
+} from "./chunk-CAPPWD3X.js";
 import {
   getVoiceSettingsScope,
   isSelectableVoiceModel,
@@ -16,7 +16,7 @@ import {
   readVoiceMode,
   readVoiceModel,
   resolveVoiceTransport
-} from "./chunk-YBL3QUDD.js";
+} from "./chunk-JTV5K7NH.js";
 import {
   WorkspacePermissionRulesSessionRequiredError,
   WorkspaceSettingsPartialPersistError,
@@ -24,15 +24,8 @@ import {
   WorkspaceSkillNotToggleableError
 } from "./chunk-OA4JVLSA.js";
 import {
-  MCP_RESTART_SERVER_DEADLINE_MS,
-  McpServerNotFoundError,
-  McpServerRestartFailedError,
-  SessionNotFoundError,
-  WorkspaceInitConflictError,
-  WorkspaceInitPathEscapeError,
-  WorkspaceInitRaceError,
-  WorkspaceInitSymlinkError
-} from "./chunk-UH3WSE5L.js";
+  MCP_RESTART_SERVER_DEADLINE_MS
+} from "./chunk-OCPBI7J5.js";
 import {
   BridgeChannelClosedError,
   SERVE_CONTROL_EXT_METHODS,
@@ -46,14 +39,26 @@ import {
   createIdleWorkspaceProvidersStatus,
   createIdleWorkspaceSkillsStatus,
   mapDomainErrorToErrorKind
-} from "./chunk-VIA5XA4U.js";
+} from "./chunk-FTD6DP4T.js";
+import {
+  resolveSkillSettings
+} from "./chunk-Z4X5MTRT.js";
+import {
+  McpServerNotFoundError,
+  McpServerRestartFailedError,
+  SessionNotFoundError,
+  WorkspaceInitConflictError,
+  WorkspaceInitPathEscapeError,
+  WorkspaceInitRaceError,
+  WorkspaceInitSymlinkError
+} from "./chunk-B4AJNNOL.js";
 import {
   getPersistScopeForModelSelection,
   loadSettings
-} from "./chunk-TEHGS6UP.js";
+} from "./chunk-EIF3FXTB.js";
 import {
   getWorkspaceTrustStatus
-} from "./chunk-Z2BC6UJ5.js";
+} from "./chunk-Q43KPN7X.js";
 import {
   writeStderrLine,
   writeStderrLineSafe
@@ -62,11 +67,11 @@ import {
   ModelsConfig,
   SkillManager,
   require_yauzl
-} from "./chunk-PHOF65IG.js";
+} from "./chunk-X5WNMMIA.js";
 import {
   Storage,
   createDebugLogger
-} from "./chunk-NL7LTRLR.js";
+} from "./chunk-UHUSJ6X7.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -885,7 +890,7 @@ function skillBaseDir(workspace, scope) {
   return scope === "workspace" ? path.join(workspace, ".qwen", "skills") : path.join(Storage.getGlobalQwenDir(), "skills");
 }
 __name(skillBaseDir, "skillBaseDir");
-async function removeInstallArtifacts(baseDir, skillName) {
+async function removeInstallArtifacts(baseDir, skillName, assertGenerationOpen) {
   const workDir = path.dirname(baseDir);
   const workPrefix = `.${path.basename(baseDir)}-${skillName}`;
   const locations = [
@@ -903,17 +908,18 @@ async function removeInstallArtifacts(baseDir, skillName) {
     await Promise.all(
       entries.filter(
         (entry) => prefixes.some((prefix) => entry.name.startsWith(prefix))
-      ).map(
-        (entry) => fs.rm(path.join(directory, entry.name), {
+      ).map(async (entry) => {
+        assertGenerationOpen?.();
+        await fs.rm(path.join(directory, entry.name), {
           recursive: true,
           force: true
-        })
-      )
+        });
+      })
     );
   }
 }
 __name(removeInstallArtifacts, "removeInstallArtifacts");
-async function ensureDirectoryWithoutSymlinks(directory) {
+async function ensureDirectoryWithoutSymlinks(directory, assertGenerationOpen) {
   const missing = [];
   let current = directory;
   while (true) {
@@ -931,15 +937,21 @@ async function ensureDirectoryWithoutSymlinks(directory) {
       current = parent;
     }
   }
-  for (const entry of missing.reverse()) await fs.mkdir(entry);
+  for (const entry of missing.reverse()) {
+    assertGenerationOpen?.();
+    await fs.mkdir(entry);
+  }
 }
 __name(ensureDirectoryWithoutSymlinks, "ensureDirectoryWithoutSymlinks");
-async function installWorkspaceSkill(workspace, request, githubToken) {
+async function installWorkspaceSkill(workspace, request, githubToken, assertGenerationOpen) {
+  assertGenerationOpen?.();
   const skillName = validateWorkspaceSkillName(request.name);
   const files = await filesFromSource(request.source, githubToken);
   const baseDir = skillBaseDir(workspace, request.scope);
-  await ensureDirectoryWithoutSymlinks(baseDir);
-  await removeInstallArtifacts(baseDir, skillName);
+  assertGenerationOpen?.();
+  await ensureDirectoryWithoutSymlinks(baseDir, assertGenerationOpen);
+  assertGenerationOpen?.();
+  await removeInstallArtifacts(baseDir, skillName, assertGenerationOpen);
   const destination = path.join(baseDir, skillName);
   const existing = await fs.lstat(destination).catch(() => void 0);
   if (existing?.isSymbolicLink() || existing && !existing.isDirectory()) {
@@ -947,15 +959,19 @@ async function installWorkspaceSkill(workspace, request, githubToken) {
   }
   const workDir = path.dirname(baseDir);
   const workPrefix = `.${path.basename(baseDir)}-${skillName}`;
+  assertGenerationOpen?.();
   const staging = await fs.mkdtemp(
     path.join(workDir, `${workPrefix}.installing-`)
   );
   const backup = path.join(workDir, `${workPrefix}.backup-${Date.now()}`);
   let movedExisting = false;
+  let committedStaging = false;
   try {
     for (const file of files) {
       const target = path.join(staging, ...file.relativePath.split("/"));
+      assertGenerationOpen?.();
       await fs.mkdir(path.dirname(target), { recursive: true });
+      assertGenerationOpen?.();
       await fs.writeFile(target, file.content);
     }
     const skillFile = path.join(staging, "SKILL.md");
@@ -979,12 +995,19 @@ async function installWorkspaceSkill(workspace, request, githubToken) {
       );
     }
     if (existing) {
+      assertGenerationOpen?.();
       await fs.rename(destination, backup);
       movedExisting = true;
     }
+    assertGenerationOpen?.();
     await fs.rename(staging, destination);
+    committedStaging = true;
+    assertGenerationOpen?.();
   } catch (error) {
-    await fs.rm(staging, { recursive: true, force: true }).catch(() => void 0);
+    await fs.rm(committedStaging ? destination : staging, {
+      recursive: true,
+      force: true
+    }).catch(() => void 0);
     if (movedExisting) {
       await fs.rename(backup, destination).catch(() => void 0);
     }
@@ -1000,7 +1023,8 @@ async function installWorkspaceSkill(workspace, request, githubToken) {
   };
 }
 __name(installWorkspaceSkill, "installWorkspaceSkill");
-async function deleteWorkspaceSkill(workspace, scope, skillNameInput, installedPath) {
+async function deleteWorkspaceSkill(workspace, scope, skillNameInput, installedPath, assertGenerationOpen) {
+  assertGenerationOpen?.();
   const skillName = validateWorkspaceSkillName(skillNameInput);
   const skillDir = path.resolve(path.dirname(installedPath));
   const skillFile = path.resolve(installedPath);
@@ -1036,6 +1060,7 @@ async function deleteWorkspaceSkill(workspace, scope, skillNameInput, installedP
       "Skill name does not match its installed directory"
     );
   }
+  assertGenerationOpen?.();
   await fs.rm(skillDir, { recursive: true, force: true });
   return { skillName, scope, deleted: true };
 }
@@ -1098,6 +1123,8 @@ __name(withTimeout, "withTimeout");
 function createDaemonWorkspaceService(deps) {
   const {
     boundWorkspace,
+    isWorkspaceTrusted,
+    assertGenerationOpen,
     contextFilename,
     statusProvider,
     workspaceProvidersStatusProvider,
@@ -1116,6 +1143,15 @@ function createDaemonWorkspaceService(deps) {
     refreshExtensionsForAllSessions: refreshExtensionsForAllSessionsOnBridge,
     publishWorkspaceEvent
   } = deps;
+  const loadBoundSettings = /* @__PURE__ */ __name((skipLoadEnvironment = false) => {
+    const workspaceTrusted = isWorkspaceTrusted();
+    return loadSettings(boundWorkspace, {
+      skipLoadEnvironment: skipLoadEnvironment || !workspaceTrusted,
+      skipWorkspaceSettings: !workspaceTrusted,
+      workspaceTrusted
+    });
+  }, "loadBoundSettings");
+  const assertActiveGeneration = /* @__PURE__ */ __name(() => assertGenerationOpen?.(), "assertActiveGeneration");
   let lastWorkspaceSkillsStatus;
   let inFlightAcpPreheat;
   const getWorkspaceSkillsStatus = /* @__PURE__ */ __name(async () => {
@@ -1188,6 +1224,7 @@ function createDaemonWorkspaceService(deps) {
       );
     },
     async preheatAcpChild(_ctx, opts) {
+      assertActiveGeneration();
       const startedAt = performance.now();
       const channelLive = /* @__PURE__ */ __name(() => isChannelLive?.() ?? false, "channelLive");
       const finish = /* @__PURE__ */ __name((result) => ({
@@ -1346,24 +1383,22 @@ function createDaemonWorkspaceService(deps) {
     },
     async getWorkspaceTrustStatus(_ctx) {
       return getWorkspaceTrustStatus(
-        loadSettings(boundWorkspace).merged,
+        loadBoundSettings(true).merged,
         boundWorkspace
       );
     },
     async getWorkspacePermissionsStatus(_ctx) {
-      return buildPermissionSettings(loadSettings(boundWorkspace));
+      return buildPermissionSettings(loadBoundSettings());
     },
     async getWorkspaceVoiceStatus(_ctx) {
       return buildWorkspaceVoiceStatus(
         boundWorkspace,
-        loadSettings(
-          boundWorkspace,
-          voiceEnv ? { skipLoadEnvironment: true } : true
-        )
+        loadBoundSettings(Boolean(voiceEnv))
       );
     },
     // -- Mutations --
     async requestWorkspaceTrustChange(ctx, request) {
+      assertActiveGeneration();
       publishWorkspaceEvent({
         type: "trust_change_requested",
         data: {
@@ -1380,6 +1415,7 @@ function createDaemonWorkspaceService(deps) {
       };
     },
     async setWorkspacePermissionRules(ctx, request) {
+      assertActiveGeneration();
       const key = `permissions.${request.ruleType}`;
       try {
         const result = await invokeWorkspaceCommand(
@@ -1391,6 +1427,7 @@ function createDaemonWorkspaceService(deps) {
             rules: request.rules
           }
         );
+        assertActiveGeneration();
         publishWorkspaceEvent({
           type: "settings_changed",
           data: { key, value: request.rules, scope: request.scope },
@@ -1405,6 +1442,7 @@ function createDaemonWorkspaceService(deps) {
       }
     },
     async setWorkspaceVoiceSettings(ctx, request) {
+      assertActiveGeneration();
       if (!persistSettings && !persistSetting) {
         throw new WorkspaceVoiceError(
           501,
@@ -1412,14 +1450,10 @@ function createDaemonWorkspaceService(deps) {
           "Workspace voice settings persistence is not available"
         );
       }
-      const settings = loadSettings(
-        boundWorkspace,
-        voiceEnv ? { skipLoadEnvironment: true } : true
-      );
+      const settings = loadBoundSettings(Boolean(voiceEnv));
       validateWorkspaceVoiceState(settings, request, { env: voiceEnv });
-      const workspaceTrusted = getWorkspaceTrustStatus(settings.merged, boundWorkspace).effective.state === "trusted";
       const writes = buildWorkspaceVoiceSettingsWrites(settings, request, {
-        workspaceTrusted,
+        workspaceTrusted: isWorkspaceTrusted(),
         ...voiceSettingsScope ? { scopeOverride: voiceSettingsScope } : {}
       });
       const publishWrite = /* @__PURE__ */ __name((write) => {
@@ -1435,15 +1469,17 @@ function createDaemonWorkspaceService(deps) {
       }, "publishWrite");
       if (persistSettings) {
         try {
-          await persistSettings(boundWorkspace, writes);
+          await persistSettings(boundWorkspace, writes, assertGenerationOpen);
         } catch (err) {
           if (err instanceof WorkspaceSettingsPartialPersistError) {
+            assertActiveGeneration();
             for (const write of err.committedWrites) {
               publishWrite(write);
             }
           }
           throw err;
         }
+        assertActiveGeneration();
         for (const write of writes) {
           publishWrite(write);
         }
@@ -1455,9 +1491,11 @@ function createDaemonWorkspaceService(deps) {
               boundWorkspace,
               write.scope,
               write.key,
-              write.value
+              write.value,
+              assertGenerationOpen
             );
           } catch (err) {
+            assertActiveGeneration();
             writeStderrLine(
               `qwen serve: workspace voice partial persist error (workspace=${boundWorkspace}, committed=${committed.length}/${writes.length}, failedKey=${write.key}, failedScope=${voiceSettingsScopeToWire(write.scope)}): ${err instanceof Error ? err.message : String(err)}`
             );
@@ -1470,22 +1508,28 @@ function createDaemonWorkspaceService(deps) {
               err
             );
           }
+          assertActiveGeneration();
           committed.push(write);
         }
+        assertActiveGeneration();
         for (const write of committed) {
           publishWrite(write);
         }
       }
       return buildWorkspaceVoiceStatus(
         boundWorkspace,
-        loadSettings(
-          boundWorkspace,
-          voiceEnv ? { skipLoadEnvironment: true } : true
-        )
+        loadBoundSettings(Boolean(voiceEnv))
       );
     },
     async setWorkspaceToolEnabled(ctx, toolName, enabled) {
-      await persistDisabledTools(boundWorkspace, toolName, enabled);
+      assertActiveGeneration();
+      await persistDisabledTools(
+        boundWorkspace,
+        toolName,
+        enabled,
+        assertGenerationOpen
+      );
+      assertActiveGeneration();
       publishWorkspaceEvent({
         type: "tool_toggled",
         data: { toolName, enabled },
@@ -1494,6 +1538,7 @@ function createDaemonWorkspaceService(deps) {
       return { toolName, enabled };
     },
     async setWorkspaceSkillEnabled(ctx, requestedSkillName, enabled) {
+      assertActiveGeneration();
       const normalizedName = requestedSkillName.trim().toLowerCase();
       const status = await getWorkspaceSkillsStatus();
       const skill = status.skills.find(
@@ -1506,11 +1551,11 @@ function createDaemonWorkspaceService(deps) {
           "not_user_invocable"
         );
       }
-      const disabled = loadSettings(boundWorkspace).merged.skills?.disabled;
-      const disabledNames = new Set(
-        (Array.isArray(disabled) ? disabled : []).filter((name) => typeof name === "string").map((name) => name.trim().toLowerCase()).filter(Boolean)
+      const needsLegacyInactiveCheck = skill.level === "extension" && skill.status === "disabled" && skill.disabledReason === void 0;
+      const disabledBySettings = needsLegacyInactiveCheck && resolveSkillSettings(loadBoundSettings(true)).disabledNames.has(
+        normalizedName
       );
-      if (skill.level === "extension" && skill.status === "disabled" && !disabledNames.has(normalizedName)) {
+      if (skill.level === "extension" && skill.status === "disabled" && (skill.disabledReason === "inactive_extension" || skill.disabledReason === void 0 && !disabledBySettings)) {
         throw new WorkspaceSkillNotToggleableError(
           skill.name,
           "inactive_extension"
@@ -1519,8 +1564,10 @@ function createDaemonWorkspaceService(deps) {
       const persisted = await persistDisabledSkills(
         boundWorkspace,
         skill.name,
-        enabled
+        enabled,
+        assertGenerationOpen
       );
+      assertActiveGeneration();
       const channelLive = isChannelLive?.() ?? false;
       let activation = channelLive ? "applied" : "deferred";
       let sessionsRefreshed = 0;
@@ -1534,6 +1581,7 @@ function createDaemonWorkspaceService(deps) {
               SERVE_CONTROL_EXT_METHODS.workspaceSkillsRefresh,
               { cwd: boundWorkspace }
             );
+            assertActiveGeneration();
             sessionsRefreshed = refreshed.sessionsRefreshed;
             sessionsFailed = refreshed.sessionsFailed;
             if (sessionsFailed > 0) activation = "partial";
@@ -1549,15 +1597,24 @@ function createDaemonWorkspaceService(deps) {
             }
           }
         }
-        publishWorkspaceEvent({
-          type: "settings_changed",
-          data: {
+        assertActiveGeneration();
+        const settingsChanges = persisted.settingsChanges ?? [
+          {
             key: "skills.disabled",
-            value: persisted.disabled.length > 0 ? persisted.disabled : void 0,
-            scope: "workspace"
-          },
-          originatorClientId: ctx.originatorClientId
-        });
+            value: persisted.disabled.length > 0 ? persisted.disabled : void 0
+          }
+        ];
+        for (const change of settingsChanges) {
+          publishWorkspaceEvent({
+            type: "settings_changed",
+            data: {
+              key: change.key,
+              value: change.value,
+              scope: "workspace"
+            },
+            originatorClientId: ctx.originatorClientId
+          });
+        }
       }
       return {
         skillName: skill.name,
@@ -1569,15 +1626,20 @@ function createDaemonWorkspaceService(deps) {
       };
     },
     async installWorkspaceSkill(_ctx, request) {
+      assertActiveGeneration();
       const result = await installWorkspaceSkill(
         boundWorkspace,
         request,
-        skillInstallEnv?.["GH_TOKEN"] ?? skillInstallEnv?.["GITHUB_TOKEN"]
+        skillInstallEnv?.["GH_TOKEN"] ?? skillInstallEnv?.["GITHUB_TOKEN"],
+        assertGenerationOpen
       );
+      assertActiveGeneration();
       await refreshWorkspaceSkillsAfterMutation();
+      assertActiveGeneration();
       return result;
     },
     async deleteWorkspaceSkill(_ctx, requestedSkillName, scope) {
+      assertActiveGeneration();
       const normalizedName = requestedSkillName.trim().toLowerCase();
       const status = await getWorkspaceSkillsStatus();
       const skill = status.skills.find(
@@ -1596,12 +1658,16 @@ function createDaemonWorkspaceService(deps) {
         boundWorkspace,
         scope,
         skill.name,
-        skill.installedPath
+        skill.installedPath,
+        assertGenerationOpen
       );
+      assertActiveGeneration();
       await refreshWorkspaceSkillsAfterMutation();
+      assertActiveGeneration();
       return result;
     },
     async initWorkspace(ctx, opts) {
+      assertActiveGeneration();
       const filename = contextFilename;
       const target = path2.resolve(boundWorkspace, filename);
       const withinWorkspace = target === boundWorkspace || target.startsWith(boundWorkspace + path2.sep);
@@ -1661,6 +1727,7 @@ function createDaemonWorkspaceService(deps) {
       if (action === "created") {
         let fh;
         try {
+          assertActiveGeneration();
           fh = await fs2.open(target, "wx");
         } catch (err) {
           const code = err?.code;
@@ -1675,6 +1742,7 @@ function createDaemonWorkspaceService(deps) {
         }
         try {
           await verifyParentPostOpen(target, wsCanonical, fh);
+          assertActiveGeneration();
           await fh.writeFile("", "utf8");
         } finally {
           await fh.close();
@@ -1682,6 +1750,7 @@ function createDaemonWorkspaceService(deps) {
       } else if (action === "overwrote") {
         let overwriteFh;
         try {
+          assertActiveGeneration();
           overwriteFh = await fs2.open(
             target,
             fsConstants.O_WRONLY | (fsConstants.O_NOFOLLOW ?? 0)
@@ -1706,11 +1775,13 @@ function createDaemonWorkspaceService(deps) {
         }
         try {
           await verifyParentPostOpen(target, wsCanonical, overwriteFh);
+          assertActiveGeneration();
           await overwriteFh.truncate(0);
         } finally {
           await overwriteFh.close();
         }
       }
+      assertActiveGeneration();
       publishWorkspaceEvent({
         type: "workspace_initialized",
         data: { path: target, action },
@@ -1719,6 +1790,7 @@ function createDaemonWorkspaceService(deps) {
       return { path: target, action };
     },
     async restartMcpServer(ctx, serverName, opts) {
+      assertActiveGeneration();
       const params = { serverName };
       if (opts?.entryIndex !== void 0) {
         params["entryIndex"] = opts.entryIndex;
@@ -1748,6 +1820,7 @@ function createDaemonWorkspaceService(deps) {
         }
         throw err;
       }
+      assertActiveGeneration();
       if ("entries" in result) {
         const entries = Array.isArray(result.entries) ? result.entries : [];
         if (!Array.isArray(result.entries)) {
@@ -1807,15 +1880,17 @@ function createDaemonWorkspaceService(deps) {
       return result;
     },
     async reload(ctx) {
+      assertActiveGeneration();
       if (deps.reloadDaemonEnv) {
         try {
-          await deps.reloadDaemonEnv(boundWorkspace);
+          await deps.reloadDaemonEnv(boundWorkspace, assertGenerationOpen);
         } catch (err) {
           writeStderrLine(
             `qwen serve: daemon reload failed: ${err instanceof Error ? err.message : String(err)}`
           );
         }
       }
+      assertActiveGeneration();
       let childReloaded = false;
       let env = {
         updatedKeys: [],
@@ -1844,6 +1919,7 @@ function createDaemonWorkspaceService(deps) {
           writeStderrLine(`qwen serve: reload failed: ${childError}`);
         }
       }
+      assertActiveGeneration();
       publishWorkspaceEvent({
         type: "settings_reloaded",
         data: {
@@ -1869,6 +1945,7 @@ function createDaemonWorkspaceService(deps) {
       lastWorkspaceSkillsStatus = void 0;
     },
     async refreshExtensionsForAllSessions() {
+      assertActiveGeneration();
       try {
         if (!refreshExtensionsForAllSessionsOnBridge) {
           throw new Error("refreshExtensionsForAllSessions is not wired");

package/chunks/{chunk-ZFDTEDCF.js → chunk-PB3MBFKG.js}

@@ -2,20 +2,20 @@
 "use strict";
 import {
   performStandaloneUpdate
-} from "./chunk-M4FMGVY4.js";
+} from "./chunk-7DXQIJID.js";
 import {
   updateEventEmitter
 } from "./chunk-YAF2MQZ6.js";
+import {
+  t
+} from "./chunk-TCIFAA7K.js";
 import {
   getInstallationInfo,
   resolveUpdateCommand
-} from "./chunk-ZNAUOR2I.js";
-import {
-  t
-} from "./chunk-LKEJ26GS.js";
+} from "./chunk-VWOOBLTY.js";
 import {
   createDebugLogger
-} from "./chunk-NL7LTRLR.js";
+} from "./chunk-UHUSJ6X7.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-3RN6GBKS.js → chunk-PLDQBIO6.js}

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