@qwen-code/qwen-code 0.20.2-jobbench-no-todo-write.0 → 0.21.0

package/chunks/{chunk-TDKQP3M6.js → chunk-HIJQF5B5.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   CHANNEL_STARTUP_PROFILE_VERSION
-} from "./chunk-QR6U5QPP.js";
+} from "./chunk-3SJ43L4W.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-NXE6SQIV.js → chunk-IJTOWOD7.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-RXFQM6FQ.js";
 import {
   CLIENT_MCP_OVER_WS_CONFIG_FLAG
-} from "./chunk-QR6U5QPP.js";
+} from "./chunk-3SJ43L4W.js";
 import {
   require_lib
 } from "./chunk-WBL3FJEU.js";
@@ -16304,9 +16304,9 @@ function parseAllowOriginPatterns(raw) {
 __name(parseAllowOriginPatterns, "parseAllowOriginPatterns");
 function allowOriginCors(patterns) {
   const allowedMethods = "GET, POST, PATCH, DELETE, OPTIONS";
-  const allowedHeaders = "Authorization, Content-Type, X-Qwen-Client-Id, Last-Event-ID";
+  const allowedHeaders = "Authorization, Content-Type, X-Qwen-Client-Id, Last-Event-ID, X-Qwen-Event-Epoch";
   const maxAgeSeconds = "86400";
-  const exposedHeaders = "Retry-After";
+  const exposedHeaders = "Retry-After, X-Qwen-Event-Epoch";
   return (req, res, next) => {
     const origin = req.headers.origin;
     if (!origin) {
@@ -16699,6 +16699,9 @@ var SERVE_CAPABILITY_REGISTRY = {
   // `POST /session/:id/generate` streams a stateless, tool-free model call.
   // The ACP child prefers fastModel and falls back to the main session model.
   session_generation: { since: "v1" },
+  // `POST /workspace/generate` runs the same stateless, tool-free generation
+  // protocol against the resolved workspace runtime without a live session.
+  workspace_generation: { since: "v1" },
   // Side question (/btw) against the session's conversation context.
   // Single-turn, tool-free LLM call via runForkedAgent (cache path).
   session_btw: { since: "v1" },
@@ -16771,6 +16774,10 @@ var SERVE_CAPABILITY_REGISTRY = {
   session_branch: { since: "v1" },
   rate_limit: { since: "v1" },
   workspace_reload: { since: "v1" },
+  // Immediate best-effort channel delivery for prompt/scheduled finals and
+  // direct workspace notifications. Presence describes the route/event
+  // contract; current worker availability is reported per delivery.
+  channel_delivery: { since: "v1" },
   // Daemon supports reloading its daemon-managed channel worker via
   // `POST /workspace/channel/reload`. The worker is stopped and relaunched;
   // on relaunch it re-reads settings.json (channels / proxy / per-channel
@@ -16897,6 +16904,10 @@ var CONDITIONAL_SERVE_FEATURES = /* @__PURE__ */ new Map([
     "session_generation",
     (toggles) => toggles.sessionGenerationAvailable === true
   ],
+  [
+    "workspace_generation",
+    (toggles) => toggles.workspaceGenerationAvailable === true
+  ],
   ["rate_limit", (toggles) => toggles.rateLimit === true],
   ["workspace_reload", (toggles) => toggles.reloadAvailable === true],
   ["channel_reload", (toggles) => toggles.channelReloadAvailable === true],

package/chunks/chunk-IKCX4CCL.js

@@ -0,0 +1,469 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  preloadRuntimeFetchModule
+} from "./chunk-2JZBVYTU.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/config/models.ts
+init_esbuild_shims();
+var DEFAULT_QWEN_MODEL = "coder-model";
+var DEFAULT_QWEN_FLASH_MODEL = "coder-model";
+var DEFAULT_QWEN_EMBEDDING_MODEL = "text-embedding-v4";
+var MAINLINE_CODER_MODEL = "qwen3.7-max";
+
+// packages/core/src/models/constants.ts
+init_esbuild_shims();
+var MODEL_GENERATION_CONFIG_FIELDS = [
+  "samplingParams",
+  "timeout",
+  "maxRetries",
+  "retryErrorCodes",
+  "enableCacheControl",
+  "forceGlobalCacheScope",
+  "schemaCompliance",
+  "reasoning",
+  "contextWindowSize",
+  "customHeaders",
+  "extra_body",
+  "thinkingMandatory",
+  "modalities",
+  "splitToolMedia",
+  "toolResultContentFormat"
+];
+var CREDENTIAL_FIELDS = [
+  "model",
+  "apiKey",
+  "apiKeyEnvKey",
+  "baseUrl"
+];
+var PROVIDER_SOURCED_FIELDS = [
+  ...CREDENTIAL_FIELDS,
+  ...MODEL_GENERATION_CONFIG_FIELDS
+];
+var AUTH_ENV_MAPPINGS = {
+  openai: {
+    apiKey: ["OPENAI_API_KEY"],
+    baseUrl: ["OPENAI_BASE_URL"],
+    model: ["OPENAI_MODEL", "QWEN_MODEL"]
+  },
+  anthropic: {
+    apiKey: ["ANTHROPIC_API_KEY"],
+    baseUrl: ["ANTHROPIC_BASE_URL"],
+    model: ["ANTHROPIC_MODEL"]
+  },
+  gemini: {
+    apiKey: ["GEMINI_API_KEY"],
+    baseUrl: [],
+    model: ["GEMINI_MODEL"]
+  },
+  "vertex-ai": {
+    apiKey: ["GOOGLE_API_KEY"],
+    baseUrl: [],
+    model: ["GOOGLE_MODEL"]
+  },
+  "qwen-oauth": {
+    apiKey: [],
+    baseUrl: [],
+    model: []
+  }
+};
+var DEFAULT_MODELS = {
+  openai: MAINLINE_CODER_MODEL,
+  "qwen-oauth": DEFAULT_QWEN_MODEL
+};
+var QWEN_OAUTH_MODELS = [
+  {
+    id: "coder-model",
+    name: "coder-model",
+    description: "Qwen 3.7 Max \u2014 efficient hybrid model with leading coding performance",
+    capabilities: { vision: true }
+  }
+];
+var QWEN_OAUTH_ALLOWED_MODELS = QWEN_OAUTH_MODELS.map(
+  (model) => model.id
+);
+
+// packages/core/src/core/contentGenerator.ts
+init_esbuild_shims();
+
+// packages/core/src/models/modelConfigErrors.ts
+init_esbuild_shims();
+function getDefaultApiKeyEnvVar(authType) {
+  switch (authType) {
+    case "openai":
+      return "OPENAI_API_KEY";
+    case "anthropic":
+      return "ANTHROPIC_API_KEY";
+    case "gemini":
+      return "GEMINI_API_KEY";
+    case "vertex-ai":
+      return "GOOGLE_API_KEY";
+    default:
+      return "API_KEY";
+  }
+}
+__name(getDefaultApiKeyEnvVar, "getDefaultApiKeyEnvVar");
+function getDefaultModelEnvVar(authType) {
+  switch (authType) {
+    case "openai":
+      return "OPENAI_MODEL";
+    case "anthropic":
+      return "ANTHROPIC_MODEL";
+    case "gemini":
+      return "GEMINI_MODEL";
+    case "vertex-ai":
+      return "GOOGLE_MODEL";
+    default:
+      return "MODEL";
+  }
+}
+__name(getDefaultModelEnvVar, "getDefaultModelEnvVar");
+var ModelConfigError = class extends Error {
+  static {
+    __name(this, "ModelConfigError");
+  }
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var StrictMissingCredentialsError = class extends ModelConfigError {
+  static {
+    __name(this, "StrictMissingCredentialsError");
+  }
+  code = "STRICT_MISSING_CREDENTIALS";
+  constructor(authType, model, envKey) {
+    const providerKey = authType || "(unknown)";
+    const modelName = model || "(unknown)";
+    super(
+      `Missing credentials for modelProviders model '${modelName}'. ` + (envKey ? `Current configured envKey: '${envKey}'. Set that environment variable, or update modelProviders.${providerKey}[].envKey.` : `Configure modelProviders.${providerKey}[].envKey and set that environment variable.`)
+    );
+  }
+};
+var StrictMissingModelIdError = class extends ModelConfigError {
+  static {
+    __name(this, "StrictMissingModelIdError");
+  }
+  code = "STRICT_MISSING_MODEL_ID";
+  constructor(authType) {
+    super(
+      `Missing model id for strict modelProviders resolution (authType: ${authType}).`
+    );
+  }
+};
+var MissingApiKeyError = class extends ModelConfigError {
+  static {
+    __name(this, "MissingApiKeyError");
+  }
+  code = "MISSING_API_KEY";
+  constructor(params) {
+    super(
+      `Missing API key for ${params.authType} auth. Current model: '${params.model || "(unknown)"}', baseUrl: '${params.baseUrl || "(default)"}'. Provide an API key via settings (security.auth.apiKey), or set the environment variable '${params.envKey}'.`
+    );
+  }
+};
+var MissingModelError = class extends ModelConfigError {
+  static {
+    __name(this, "MissingModelError");
+  }
+  code = "MISSING_MODEL";
+  constructor(params) {
+    super(
+      `Missing model for ${params.authType} auth. Set the environment variable '${params.envKey}'.`
+    );
+  }
+};
+var MissingBaseUrlError = class extends ModelConfigError {
+  static {
+    __name(this, "MissingBaseUrlError");
+  }
+  code = "MISSING_BASE_URL";
+  constructor(params) {
+    super(
+      `Missing baseUrl for modelProviders model '${params.model || "(unknown)"}'. Configure modelProviders.${params.authType || "(unknown)"}[].baseUrl.`
+    );
+  }
+};
+var MissingAnthropicBaseUrlEnvError = class extends ModelConfigError {
+  static {
+    __name(this, "MissingAnthropicBaseUrlEnvError");
+  }
+  code = "MISSING_ANTHROPIC_BASE_URL_ENV";
+  constructor() {
+    super("ANTHROPIC_BASE_URL environment variable not found.");
+  }
+};
+
+// packages/core/src/core/contentGenerator.ts
+var AuthType = /* @__PURE__ */ ((AuthType2) => {
+  AuthType2["USE_OPENAI"] = "openai";
+  AuthType2["QWEN_OAUTH"] = "qwen-oauth";
+  AuthType2["USE_GEMINI"] = "gemini";
+  AuthType2["USE_VERTEX_AI"] = "vertex-ai";
+  AuthType2["USE_ANTHROPIC"] = "anthropic";
+  return AuthType2;
+})(AuthType || {});
+function setSource(sources, path, source) {
+  sources[path] = source;
+}
+__name(setSource, "setSource");
+function getSeedSource(seed, path) {
+  return seed?.[path];
+}
+__name(getSeedSource, "getSeedSource");
+function resolveContentGeneratorConfigWithSources(config, authType, generationConfig, seedSources, options) {
+  const sources = { ...seedSources || {} };
+  const strictModelProvider = options?.strictModelProvider === true;
+  const newContentGeneratorConfig = {
+    ...generationConfig || {},
+    authType,
+    proxy: config?.getProxy()
+  };
+  setSource(sources, "authType", {
+    kind: "computed",
+    detail: "provided by caller"
+  });
+  if (config?.getProxy()) {
+    setSource(sources, "proxy", {
+      kind: "computed",
+      detail: "Config.getProxy()"
+    });
+  }
+  const seedOrUnknown = /* @__PURE__ */ __name((path) => getSeedSource(seedSources, path) ?? { kind: "unknown" }, "seedOrUnknown");
+  for (const field of PROVIDER_SOURCED_FIELDS) {
+    if (generationConfig && field in generationConfig && !sources[field]) {
+      setSource(sources, field, seedOrUnknown(field));
+    }
+  }
+  const validation = validateModelConfig(
+    newContentGeneratorConfig,
+    strictModelProvider
+  );
+  if (!validation.valid) {
+    throw new Error(validation.errors.map((e) => e.message).join("\n"));
+  }
+  return {
+    config: newContentGeneratorConfig,
+    sources
+  };
+}
+__name(resolveContentGeneratorConfigWithSources, "resolveContentGeneratorConfigWithSources");
+function validateModelConfig(config, isStrictModelProvider = false) {
+  const errors = [];
+  if (config.authType === "qwen-oauth" /* QWEN_OAUTH */) {
+    return { valid: true, errors: [] };
+  }
+  if (!config.apiKey) {
+    if (isStrictModelProvider) {
+      errors.push(
+        new StrictMissingCredentialsError(
+          config.authType,
+          config.model,
+          config.apiKeyEnvKey
+        )
+      );
+    } else {
+      const envKey = config.apiKeyEnvKey || getDefaultApiKeyEnvVar(config.authType);
+      errors.push(
+        new MissingApiKeyError({
+          authType: config.authType,
+          model: config.model,
+          baseUrl: config.baseUrl,
+          envKey
+        })
+      );
+    }
+  }
+  if (!config.model) {
+    if (isStrictModelProvider) {
+      errors.push(new StrictMissingModelIdError(config.authType));
+    } else {
+      const envKey = getDefaultModelEnvVar(config.authType);
+      errors.push(new MissingModelError({ authType: config.authType, envKey }));
+    }
+  }
+  if (config.authType === "anthropic" /* USE_ANTHROPIC */ && !config.baseUrl) {
+    if (isStrictModelProvider) {
+      errors.push(
+        new MissingBaseUrlError({
+          authType: config.authType,
+          model: config.model
+        })
+      );
+    } else if (config.authType === "anthropic" /* USE_ANTHROPIC */) {
+      errors.push(new MissingAnthropicBaseUrlEnvError());
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+__name(validateModelConfig, "validateModelConfig");
+function createContentGeneratorConfig(config, authType, generationConfig) {
+  return resolveContentGeneratorConfigWithSources(
+    config,
+    authType,
+    generationConfig
+  ).config;
+}
+__name(createContentGeneratorConfig, "createContentGeneratorConfig");
+function getModuleNotFoundError(error) {
+  let current = error;
+  while (current instanceof Error) {
+    if ("code" in current && current.code === "ERR_MODULE_NOT_FOUND") {
+      return current;
+    }
+    current = current.cause;
+  }
+  return void 0;
+}
+__name(getModuleNotFoundError, "getModuleNotFoundError");
+function wrapProviderLoadError(error, authType) {
+  const moduleNotFoundError = getModuleNotFoundError(error);
+  if (!moduleNotFoundError) {
+    return error;
+  }
+  return new Error(
+    `Qwen Code was updated in the background and needs to be restarted.
+Please exit and restart Qwen Code to use the '${authType}' provider.`,
+    { cause: moduleNotFoundError }
+  );
+}
+__name(wrapProviderLoadError, "wrapProviderLoadError");
+var LazyContentGenerator = class {
+  constructor(loader, summarizedThinking) {
+    this.loader = loader;
+    this.summarizedThinking = summarizedThinking;
+  }
+  static {
+    __name(this, "LazyContentGenerator");
+  }
+  generatorPromise;
+  getGenerator() {
+    this.generatorPromise ??= this.loader();
+    return this.generatorPromise;
+  }
+  async generateContent(request, userPromptId) {
+    return (await this.getGenerator()).generateContent(request, userPromptId);
+  }
+  async generateContentStream(request, userPromptId) {
+    return (await this.getGenerator()).generateContentStream(
+      request,
+      userPromptId
+    );
+  }
+  async countTokens(request) {
+    return (await this.getGenerator()).countTokens(request);
+  }
+  async embedContent(request) {
+    return (await this.getGenerator()).embedContent(request);
+  }
+  useSummarizedThinking() {
+    return this.summarizedThinking;
+  }
+};
+async function createContentGenerator(generatorConfig, config, isInitialAuth) {
+  const validation = validateModelConfig(generatorConfig, false);
+  if (!validation.valid) {
+    throw new Error(validation.errors.map((e) => e.message).join("\n"));
+  }
+  const authType = generatorConfig.authType;
+  if (!authType) {
+    throw new Error("ContentGeneratorConfig must have an authType");
+  }
+  await preloadRuntimeFetchModule();
+  let loadBaseGenerator;
+  try {
+    if (authType === "openai" /* USE_OPENAI */) {
+      loadBaseGenerator = /* @__PURE__ */ __name(async () => {
+        const { createOpenAIContentGenerator } = await import("./openaiContentGenerator-WMCU3O2H.js");
+        return createOpenAIContentGenerator(generatorConfig, config);
+      }, "loadBaseGenerator");
+    } else if (authType === "qwen-oauth" /* QWEN_OAUTH */) {
+      const { getQwenOAuthClient: getQwenOauthClient } = await import("./qwenOAuth2-OWLB5AKH.js");
+      try {
+        const qwenClient = await getQwenOauthClient(
+          config,
+          isInitialAuth ? { requireCachedCredentials: true } : void 0
+        );
+        loadBaseGenerator = /* @__PURE__ */ __name(async () => {
+          const { QwenContentGenerator } = await import("./qwenContentGenerator-HHCRK4SX.js");
+          return new QwenContentGenerator(qwenClient, generatorConfig, config);
+        }, "loadBaseGenerator");
+      } catch (error) {
+        if (getModuleNotFoundError(error)) {
+          throw error;
+        }
+        throw new Error(error instanceof Error ? error.message : String(error));
+      }
+    } else if (authType === "anthropic" /* USE_ANTHROPIC */) {
+      loadBaseGenerator = /* @__PURE__ */ __name(async () => {
+        const { createAnthropicContentGenerator } = await import("./anthropicContentGenerator-75BKLTSP.js");
+        return createAnthropicContentGenerator(generatorConfig, config);
+      }, "loadBaseGenerator");
+    } else if (authType === "gemini" /* USE_GEMINI */ || authType === "vertex-ai" /* USE_VERTEX_AI */) {
+      loadBaseGenerator = /* @__PURE__ */ __name(async () => {
+        const { createGeminiContentGenerator } = await import("./geminiContentGenerator-AG4KB6CV.js");
+        return createGeminiContentGenerator(generatorConfig, config);
+      }, "loadBaseGenerator");
+    } else {
+      throw new Error(
+        `Error creating contentGenerator: Unsupported authType: ${authType}`
+      );
+    }
+  } catch (error) {
+    throw wrapProviderLoadError(error, authType);
+  }
+  return new LazyContentGenerator(
+    async () => {
+      try {
+        const [baseGenerator, { LoggingContentGenerator }] = await Promise.all([
+          loadBaseGenerator(),
+          import("./loggingContentGenerator-HS3S5H3Q.js")
+        ]);
+        return new LoggingContentGenerator(
+          baseGenerator,
+          config,
+          generatorConfig
+        );
+      } catch (error) {
+        throw wrapProviderLoadError(error, authType);
+      }
+    },
+    authType === "gemini" /* USE_GEMINI */ || authType === "vertex-ai" /* USE_VERTEX_AI */
+  );
+}
+__name(createContentGenerator, "createContentGenerator");
+
+export {
+  DEFAULT_QWEN_MODEL,
+  DEFAULT_QWEN_FLASH_MODEL,
+  DEFAULT_QWEN_EMBEDDING_MODEL,
+  MAINLINE_CODER_MODEL,
+  MODEL_GENERATION_CONFIG_FIELDS,
+  PROVIDER_SOURCED_FIELDS,
+  AUTH_ENV_MAPPINGS,
+  DEFAULT_MODELS,
+  QWEN_OAUTH_MODELS,
+  QWEN_OAUTH_ALLOWED_MODELS,
+  AuthType,
+  resolveContentGeneratorConfigWithSources,
+  validateModelConfig,
+  createContentGeneratorConfig,
+  createContentGenerator
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-7SSWNGEJ.js → chunk-IKYJHJNF.js}

@@ -6,16 +6,16 @@ import {
 import {
   JsonFormatter,
   parseAndFormatApiError
-} from "./chunk-IWALV67J.js";
+} from "./chunk-PHOF65IG.js";
 import {
   FatalBudgetExceededError,
   FatalCancellationError,
   FatalTurnLimitedError,
   createDebugLogger
-} from "./chunk-OQB4EXO4.js";
+} from "./chunk-NL7LTRLR.js";
 import {
   runExitCleanup
-} from "./chunk-GSX6P2JW.js";
+} from "./chunk-PWVFN2LF.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-64XKYOXK.js → chunk-IO3IX5Q4.js}

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

package/chunks/{chunk-RS7MT2QG.js → chunk-IPUUTYMV.js}

@@ -2,12 +2,11 @@
 "use strict";
 import {
   stringWidth
-} from "./chunk-H2XVO6NE.js";
+} from "./chunk-2MIN6GRR.js";
 import {
   ansiRegex,
-  init_ansi_regex,
   stripAnsi
-} from "./chunk-T4TZQJ7W.js";
+} from "./chunk-TWPJO254.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -17,7 +16,6 @@ import {
 
 // packages/cli/src/ui/utils/textUtils.ts
 init_esbuild_shims();
-init_ansi_regex();
 import { stripVTControlCharacters } from "node:util";
 var getAsciiArtWidth = /* @__PURE__ */ __name((asciiArt) => {
   if (!asciiArt) {

package/chunks/{chunk-XU457J4V.js → chunk-IRH27ZC2.js}

@@ -97,8 +97,8 @@ function parseCron(cronExpr) {
     dayOfMonth: parseField(parts[2], FIELD_RANGES[2][0], FIELD_RANGES[2][1]),
     month: parseField(parts[3], FIELD_RANGES[3][0], FIELD_RANGES[3][1]),
     dayOfWeek,
-    domIsWild: parts[2].trim() === "*",
-    dowIsWild: parts[4].trim() === "*"
+    domIsWild: parts[2].trim().startsWith("*"),
+    dowIsWild: parts[4].trim().startsWith("*")
   };
 }
 __name(parseCron, "parseCron");

package/chunks/{chunk-SVIMKSEI.js → chunk-J24WCGIN.js}

@@ -3,17 +3,17 @@
 import {
   getGitVersion,
   getNpmVersion
-} from "./chunk-CJQ3FZ2G.js";
+} from "./chunk-MVSUYZDT.js";
 import {
   buildEnvStatusFromEnv,
   snapshotProcessEnv
-} from "./chunk-P2BQZ7H7.js";
+} from "./chunk-ETSW4KLJ.js";
 import {
   mapDomainErrorToErrorKind
-} from "./chunk-TDDFEPBX.js";
+} from "./chunk-VIA5XA4U.js";
 import {
   canUseRipgrep
-} from "./chunk-IWALV67J.js";
+} from "./chunk-PHOF65IG.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-4LVZNIDO.js → chunk-J56UI34H.js}

@@ -1,8 +1,11 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  wrapForMultiplexer
+} from "./chunk-EPDRMGT4.js";
 import {
   createDebugLogger
-} from "./chunk-OQB4EXO4.js";
+} from "./chunk-NL7LTRLR.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -88,17 +91,6 @@ function osc(...parts) {
   return `${OSC_PREFIX}${sanitized.join(SEP)}${terminator}`;
 }
 __name(osc, "osc");
-function wrapForMultiplexer(sequence) {
-  if (process.env["TMUX"]) {
-    const escaped = sequence.replaceAll("\x1B", "\x1B\x1B");
-    return `\x1BPtmux;${escaped}\x1B\\`;
-  }
-  if (process.env["STY"]) {
-    return `\x1BP${sequence}\x1B\\`;
-  }
-  return sequence;
-}
-__name(wrapForMultiplexer, "wrapForMultiplexer");
 function encodeKittyPayload(text) {
   return Buffer.from(text, "utf8").toString("base64");
 }
@@ -602,7 +594,6 @@ export {
   BEL,
   OSC_PREFIX,
   detectTerminal,
-  wrapForMultiplexer,
   oscITerm2Notify,
   oscKittyNotify,
   oscGhosttyNotify,

package/chunks/{chunk-TJTKSVIV.js → chunk-JLU636DO.js}

@@ -9,6 +9,10 @@ import {
 
 // packages/cli/src/serve/channel-selection.ts
 init_esbuild_shims();
+function isAllChannelSelectionName(name) {
+  return name.trim() === "all";
+}
+__name(isAllChannelSelectionName, "isAllChannelSelectionName");
 function normalizeServeChannelSelection(rawChannels) {
   if (rawChannels === void 0 || rawChannels.length === 0) {
     return void 0;
@@ -24,7 +28,7 @@ function normalizeServeChannelSelection(rawChannels) {
     seen.add(name);
     names.push(name);
   }
-  if (seen.has("all")) {
+  if (names.some(isAllChannelSelectionName)) {
     if (names.length > 1) {
       throw new Error("--channel all cannot be combined with channel names.");
     }