@qwen-code/qwen-code 0.21.0 → 0.21.1

package/chunks/chunk-JYBU6YUE.js

@@ -0,0 +1,378 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  SessionNotFoundError
+} from "./chunk-B4AJNNOL.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/serve/workspace-registry.ts
+init_esbuild_shims();
+var WorkspaceGenerationClosedError = class extends Error {
+  static {
+    __name(this, "WorkspaceGenerationClosedError");
+  }
+  code = "workspace_generation_closed";
+  constructor(message = "Workspace runtime generation is no longer active.") {
+    super(message);
+    this.name = "WorkspaceGenerationClosedError";
+  }
+};
+function createWorkspaceGenerationGuard() {
+  let closed = false;
+  return {
+    get closed() {
+      return closed;
+    },
+    assertOpen() {
+      if (closed) throw new WorkspaceGenerationClosedError();
+    },
+    close() {
+      closed = true;
+    }
+  };
+}
+__name(createWorkspaceGenerationGuard, "createWorkspaceGenerationGuard");
+function createWorkspaceSessionOwnerIndex() {
+  const bySessionId = /* @__PURE__ */ new Map();
+  const register = /* @__PURE__ */ __name((sessionId, workspaceCwd) => {
+    let owners = bySessionId.get(sessionId);
+    if (!owners) {
+      owners = /* @__PURE__ */ new Set();
+      bySessionId.set(sessionId, owners);
+    }
+    owners.add(workspaceCwd);
+  }, "register");
+  const remove = /* @__PURE__ */ __name((sessionId, workspaceCwd) => {
+    if (workspaceCwd === void 0) {
+      bySessionId.delete(sessionId);
+      return;
+    }
+    const owners = bySessionId.get(sessionId);
+    if (!owners) return;
+    owners.delete(workspaceCwd);
+    if (owners.size === 0) {
+      bySessionId.delete(sessionId);
+    }
+  }, "remove");
+  return {
+    register,
+    remove,
+    getWorkspaceCwds: /* @__PURE__ */ __name((sessionId) => [...bySessionId.get(sessionId) ?? []], "getWorkspaceCwds"),
+    removeWorkspace: /* @__PURE__ */ __name((workspaceCwd) => {
+      for (const [sessionId, owners] of bySessionId) {
+        owners.delete(workspaceCwd);
+        if (owners.size === 0) bySessionId.delete(sessionId);
+      }
+    }, "removeWorkspace"),
+    handleBridgeSessionLifecycle: /* @__PURE__ */ __name((event) => {
+      if (event.type === "registered") {
+        register(event.sessionId, event.workspaceCwd);
+      } else {
+        remove(event.sessionId, event.workspaceCwd);
+      }
+    }, "handleBridgeSessionLifecycle")
+  };
+}
+__name(createWorkspaceSessionOwnerIndex, "createWorkspaceSessionOwnerIndex");
+function createWorkspaceRegistry(inputRuntimes, options = {}) {
+  if (inputRuntimes.length === 0) {
+    throw new Error(
+      "WorkspaceRegistry requires at least one workspace runtime."
+    );
+  }
+  const primaryRuntimes = inputRuntimes.filter((runtime) => runtime.primary);
+  if (primaryRuntimes.length !== 1) {
+    throw new Error(
+      "WorkspaceRegistry requires exactly one primary workspace runtime."
+    );
+  }
+  const byCwd = /* @__PURE__ */ new Map();
+  const byId = /* @__PURE__ */ new Map();
+  const createEntry = /* @__PURE__ */ __name((runtime, generationId) => ({
+    workspaceId: runtime.workspaceId,
+    workspaceCwd: runtime.workspaceCwd,
+    ...runtime.displayName !== void 0 ? { displayName: runtime.displayName } : {},
+    primary: runtime.primary,
+    removable: runtime.removable === true,
+    registrationIds: Object.freeze([...runtime.registrationIds ?? []]),
+    lastGenerationId: generationId,
+    state: "active",
+    current: {
+      generationId,
+      policyRevision: "boot",
+      runtime,
+      guard: runtime.generationGuard ?? createWorkspaceGenerationGuard()
+    },
+    configuredRevision: "boot",
+    appliedRevision: "boot"
+  }), "createEntry");
+  const entries = [];
+  for (const runtime of inputRuntimes) {
+    if (byCwd.has(runtime.workspaceCwd)) {
+      throw new Error(
+        `Duplicate workspace runtime cwd ${JSON.stringify(
+          runtime.workspaceCwd
+        )}.`
+      );
+    }
+    const entry = createEntry(runtime, 1);
+    byCwd.set(runtime.workspaceCwd, entry);
+    if (byId.has(runtime.workspaceId)) {
+      throw new Error(
+        `Duplicate workspace runtime id ${JSON.stringify(
+          runtime.workspaceId
+        )}.`
+      );
+    }
+    byId.set(runtime.workspaceId, entry);
+    entries.push(entry);
+  }
+  const primaryEntry = entries.find((entry) => entry.primary);
+  const entryForRuntime = /* @__PURE__ */ __name((runtime) => {
+    const entry = byId.get(runtime.workspaceId);
+    return entry?.current?.runtime === runtime ? entry : void 0;
+  }, "entryForRuntime");
+  const activeRuntime = /* @__PURE__ */ __name((entry) => entry?.state === "active" ? entry.current?.runtime : void 0, "activeRuntime");
+  const requirePrimaryRuntime = /* @__PURE__ */ __name(() => {
+    const runtime = primaryEntry.state === "active" ? primaryEntry.current?.runtime : void 0;
+    if (!runtime) {
+      throw new WorkspaceGenerationClosedError(
+        "Primary workspace runtime is unavailable."
+      );
+    }
+    return runtime;
+  }, "requirePrimaryRuntime");
+  const sessionOwnerIndex = options.sessionOwnerIndex;
+  const scanLiveOwners = /* @__PURE__ */ __name((sessionId) => {
+    const matches = [];
+    for (const entry of entries) {
+      const runtime = activeRuntime(entry);
+      if (!runtime) continue;
+      try {
+        runtime.bridge.getSessionSummary(sessionId);
+        matches.push(runtime);
+      } catch (err) {
+        if (err instanceof SessionNotFoundError) continue;
+        throw err;
+      }
+    }
+    for (const match of matches) {
+      sessionOwnerIndex?.register(sessionId, match.workspaceCwd);
+    }
+    if (matches.length === 0) return { kind: "not_found" };
+    if (matches.length === 1) {
+      return { kind: "found", runtime: matches[0] };
+    }
+    return { kind: "ambiguous", runtimes: matches };
+  }, "scanLiveOwners");
+  return {
+    get primary() {
+      return requirePrimaryRuntime();
+    },
+    primaryEntry,
+    // Return a frozen snapshot: `runtimes` is mutable internally (see `add`),
+    // but callers must not be able to push/splice into the registry's state.
+    list: /* @__PURE__ */ __name(() => Object.freeze(
+      entries.flatMap((entry) => {
+        const runtime = activeRuntime(entry);
+        return runtime ? [runtime] : [];
+      })
+    ), "list"),
+    listEntries: /* @__PURE__ */ __name(() => Object.freeze(
+      entries.filter((entry) => entry.state !== "removed")
+    ), "listEntries"),
+    listManaged: /* @__PURE__ */ __name(() => Object.freeze(
+      entries.flatMap(
+        (entry) => entry.current?.runtime ? [entry.current.runtime] : []
+      )
+    ), "listManaged"),
+    getEntryByWorkspaceCwd: /* @__PURE__ */ __name((workspaceCwd) => byCwd.get(workspaceCwd), "getEntryByWorkspaceCwd"),
+    getEntryByWorkspaceId: /* @__PURE__ */ __name((workspaceId) => byId.get(workspaceId), "getEntryByWorkspaceId"),
+    beginReplacement: /* @__PURE__ */ __name((entry, configuredRevision) => {
+      if (entry.state === "blocked") {
+        entry.configuredRevision = configuredRevision;
+        entry.state = "transitioning";
+        entry.current?.guard.close();
+        sessionOwnerIndex?.removeWorkspace(entry.workspaceCwd);
+        delete entry.applyError;
+        return true;
+      }
+      if (entry.state !== "active" || !entry.current) return false;
+      entry.configuredRevision = configuredRevision;
+      entry.state = "transitioning";
+      entry.current.guard.close();
+      sessionOwnerIndex?.removeWorkspace(entry.workspaceCwd);
+      delete entry.applyError;
+      return true;
+    }, "beginReplacement"),
+    activateReplacement: /* @__PURE__ */ __name((entry, runtime, policyRevision) => {
+      if (entry.state !== "transitioning") {
+        throw new Error(
+          "Replacement runtime can only activate a transitioning entry."
+        );
+      }
+      if (runtime.workspaceId !== entry.workspaceId || runtime.workspaceCwd !== entry.workspaceCwd || runtime.primary !== entry.primary) {
+        throw new Error("Replacement runtime identity does not match entry.");
+      }
+      if (entry.displayName === void 0) {
+        delete runtime.displayName;
+      } else {
+        runtime.displayName = entry.displayName;
+      }
+      runtime.registrationIds = [...entry.registrationIds];
+      const generationId = entry.lastGenerationId + 1;
+      const generation = {
+        generationId,
+        policyRevision,
+        runtime,
+        guard: runtime.generationGuard ?? createWorkspaceGenerationGuard()
+      };
+      entry.lastGenerationId = generationId;
+      entry.current = generation;
+      entry.configuredRevision = policyRevision;
+      entry.appliedRevision = policyRevision;
+      entry.state = "active";
+      delete entry.applyError;
+      return generation;
+    }, "activateReplacement"),
+    advancePolicyRevision: /* @__PURE__ */ __name((entry, policyRevision) => {
+      entry.configuredRevision = policyRevision;
+      entry.appliedRevision = policyRevision;
+      if (entry.current) {
+        entry.current = { ...entry.current, policyRevision };
+      }
+      delete entry.applyError;
+    }, "advancePolicyRevision"),
+    blockReplacement: /* @__PURE__ */ __name((entry, error) => {
+      entry.current?.guard.close();
+      entry.state = "blocked";
+      entry.appliedRevision = null;
+      entry.applyError = error;
+    }, "blockReplacement"),
+    getByWorkspaceCwd: /* @__PURE__ */ __name((workspaceCwd) => activeRuntime(byCwd.get(workspaceCwd)), "getByWorkspaceCwd"),
+    getByWorkspaceId: /* @__PURE__ */ __name((workspaceId) => activeRuntime(byId.get(workspaceId)), "getByWorkspaceId"),
+    getManagedByWorkspaceCwd: /* @__PURE__ */ __name((workspaceCwd) => byCwd.get(workspaceCwd)?.current?.runtime, "getManagedByWorkspaceCwd"),
+    getManagedByWorkspaceId: /* @__PURE__ */ __name((workspaceId) => byId.get(workspaceId)?.current?.runtime, "getManagedByWorkspaceId"),
+    syncRuntimeMetadata: /* @__PURE__ */ __name((runtime) => {
+      const entry = byCwd.get(runtime.workspaceCwd);
+      if (!entry || entry.workspaceId !== runtime.workspaceId) return;
+      if (runtime.displayName === void 0) {
+        delete entry.displayName;
+      } else {
+        entry.displayName = runtime.displayName;
+      }
+      entry.registrationIds = Object.freeze([
+        ...runtime.registrationIds ?? []
+      ]);
+      const current = entry.current?.runtime;
+      if (!current || current === runtime) return;
+      if (entry.displayName === void 0) {
+        delete current.displayName;
+      } else {
+        current.displayName = entry.displayName;
+      }
+      current.registrationIds = [...entry.registrationIds];
+    }, "syncRuntimeMetadata"),
+    resolveWorkspaceCwd: /* @__PURE__ */ __name((workspaceCwd) => workspaceCwd === void 0 ? activeRuntime(primaryEntry) : activeRuntime(byCwd.get(workspaceCwd)), "resolveWorkspaceCwd"),
+    add: /* @__PURE__ */ __name((runtime) => {
+      if (byCwd.has(runtime.workspaceCwd)) {
+        throw new Error(
+          `Duplicate workspace runtime cwd ${JSON.stringify(runtime.workspaceCwd)}.`
+        );
+      }
+      if (byId.has(runtime.workspaceId)) {
+        throw new Error(
+          `Duplicate workspace runtime id ${JSON.stringify(runtime.workspaceId)}.`
+        );
+      }
+      const entry = createEntry(runtime, 1);
+      byCwd.set(runtime.workspaceCwd, entry);
+      byId.set(runtime.workspaceId, entry);
+      entries.push(entry);
+    }, "add"),
+    beginDrain: /* @__PURE__ */ __name((runtime) => {
+      const entry = entryForRuntime(runtime);
+      if (!entry || runtime.primary || entry.state !== "active") return false;
+      entry.state = "draining";
+      return true;
+    }, "beginDrain"),
+    cancelDrain: /* @__PURE__ */ __name((runtime) => {
+      const entry = entryForRuntime(runtime);
+      if (entry?.state === "draining" && entry.current?.guard.closed !== true) {
+        entry.state = "active";
+      }
+    }, "cancelDrain"),
+    commitDrain: /* @__PURE__ */ __name((runtime) => {
+      const entry = entryForRuntime(runtime);
+      if (!entry || runtime.primary || entry.state !== "draining") return;
+      entry.current?.guard.close();
+      sessionOwnerIndex?.removeWorkspace(runtime.workspaceCwd);
+    }, "commitDrain"),
+    completeDrain: /* @__PURE__ */ __name((runtime) => {
+      const entry = entryForRuntime(runtime);
+      if (!entry || runtime.primary || entry.state !== "draining") return;
+      entry.current?.guard.close();
+      entry.state = "removed";
+      byCwd.delete(runtime.workspaceCwd);
+      byId.delete(runtime.workspaceId);
+      const index = entries.indexOf(entry);
+      if (index >= 0) entries.splice(index, 1);
+      sessionOwnerIndex?.removeWorkspace(runtime.workspaceCwd);
+    }, "completeDrain"),
+    resolveLiveSessionOwner: /* @__PURE__ */ __name((sessionId) => {
+      const indexedCwds = sessionOwnerIndex?.getWorkspaceCwds(sessionId) ?? [];
+      if (indexedCwds.length > 0) {
+        const matches = [];
+        for (const workspaceCwd of indexedCwds) {
+          const entry = byCwd.get(workspaceCwd);
+          const runtime = entry?.current?.runtime;
+          if (!entry || !runtime || entry.state === "removed") {
+            sessionOwnerIndex?.remove(sessionId, workspaceCwd);
+            continue;
+          }
+          if (entry.state !== "active") continue;
+          try {
+            runtime.bridge.getSessionSummary(sessionId);
+            matches.push(runtime);
+          } catch (err) {
+            if (err instanceof SessionNotFoundError) {
+              sessionOwnerIndex?.remove(sessionId, workspaceCwd);
+              continue;
+            }
+            throw err;
+          }
+        }
+        if (matches.length === 1) {
+          return { kind: "found", runtime: matches[0] };
+        }
+        if (matches.length > 1) {
+          return { kind: "ambiguous", runtimes: matches };
+        }
+      }
+      return options.scanUnindexedOwners !== false ? scanLiveOwners(sessionId) : { kind: "not_found" };
+    }, "resolveLiveSessionOwner")
+  };
+}
+__name(createWorkspaceRegistry, "createWorkspaceRegistry");
+function createSingleWorkspaceRegistry(runtime, options = {}) {
+  return createWorkspaceRegistry([runtime], options);
+}
+__name(createSingleWorkspaceRegistry, "createSingleWorkspaceRegistry");
+
+export {
+  WorkspaceGenerationClosedError,
+  createWorkspaceGenerationGuard,
+  createWorkspaceSessionOwnerIndex,
+  createWorkspaceRegistry,
+  createSingleWorkspaceRegistry
+};
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-7JURR4JT.js → chunk-KAMYKP7E.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   MissingCliEntryError
-} from "./chunk-VIA5XA4U.js";
+} from "./chunk-FTD6DP4T.js";
 import {
   redactLogCredentials
 } from "./chunk-M5GB774H.js";
@@ -125,6 +125,144 @@ function callHook(hook, value) {
 }
 __name(callHook, "callHook");
 
+// packages/acp-bridge/src/process-registry.ts
+init_esbuild_shims();
+var TERM_GRACE_MS = 5e3;
+var EXIT_DEADLINE_MS = 1e4;
+var ProcessRegistry = class {
+  static {
+    __name(this, "ProcessRegistry");
+  }
+  reservations = /* @__PURE__ */ new Set();
+  children = /* @__PURE__ */ new Set();
+  draining = false;
+  shutdownPromise;
+  reserve() {
+    if (this.draining) {
+      throw new Error("ACP process registry is draining");
+    }
+    const token = Symbol("acp-child");
+    this.reservations.add(token);
+    let settled = false;
+    return {
+      attach: /* @__PURE__ */ __name((child) => {
+        if (settled || !this.reservations.delete(token)) {
+          throw new Error("ACP process reservation is no longer active");
+        }
+        settled = true;
+        const tracked = new TrackedChild(child, () => {
+          this.children.delete(tracked);
+        });
+        this.children.add(tracked);
+        if (this.draining) void tracked.terminate().catch(() => {
+        });
+        return tracked;
+      }, "attach"),
+      cancel: /* @__PURE__ */ __name(() => {
+        if (settled) return;
+        settled = true;
+        this.reservations.delete(token);
+      }, "cancel")
+    };
+  }
+  shutdown() {
+    if (this.shutdownPromise) return this.shutdownPromise;
+    this.draining = true;
+    this.shutdownPromise = Promise.allSettled(
+      [...this.children].map((child) => child.terminate())
+    ).then((results) => {
+      const failures = results.flatMap(
+        (result) => result.status === "rejected" ? [result.reason] : []
+      );
+      if (failures.length > 0) {
+        throw new AggregateError(failures, "ACP child process shutdown failed");
+      }
+    });
+    return this.shutdownPromise;
+  }
+  killAllSync() {
+    this.draining = true;
+    for (const child of this.children) child.killSync();
+  }
+  get activeProcessCount() {
+    return this.children.size;
+  }
+};
+var TrackedChild = class {
+  constructor(child, onExit) {
+    this.child = child;
+    this.onExit = onExit;
+    this.exited = new Promise((resolve) => {
+      const finish = /* @__PURE__ */ __name((info) => {
+        if (this.exitedSettled) return;
+        this.exitedSettled = true;
+        this.onExit();
+        resolve(info);
+      }, "finish");
+      child.once("exit", (exitCode, signalCode) => {
+        finish({ exitCode, signalCode });
+      });
+      child.once("spawn", () => {
+        this.spawnConfirmed = true;
+      });
+      child.once("error", () => {
+        if (!this.spawnConfirmed) finish(void 0);
+      });
+    });
+  }
+  static {
+    __name(this, "TrackedChild");
+  }
+  exited;
+  exitedSettled = false;
+  spawnConfirmed = false;
+  terminatePromise;
+  terminate() {
+    this.terminatePromise ??= this.terminateOnce();
+    return this.terminatePromise;
+  }
+  killSync() {
+    if (this.exitedSettled) return;
+    try {
+      this.child.kill("SIGKILL");
+    } catch {
+    }
+  }
+  async terminateOnce() {
+    if (this.exitedSettled) return;
+    try {
+      this.child.kill("SIGTERM");
+    } catch {
+      if (this.exitedSettled) return;
+    }
+    let hardKillTimer;
+    let deadlineTimer;
+    const deadline = new Promise((_, reject) => {
+      hardKillTimer = setTimeout(() => this.killSync(), TERM_GRACE_MS);
+      hardKillTimer.unref();
+      deadlineTimer = setTimeout(() => {
+        reject(
+          new Error(
+            `ACP child pid=${this.child.pid ?? "unknown"} did not exit within ${EXIT_DEADLINE_MS}ms`
+          )
+        );
+      }, EXIT_DEADLINE_MS);
+      deadlineTimer.unref();
+    });
+    try {
+      const exitInfo = await Promise.race([this.exited, deadline]);
+      if (exitInfo && (exitInfo.exitCode !== 0 || exitInfo.signalCode !== null)) {
+        throw new Error(
+          `ACP child pid=${this.child.pid ?? "unknown"} exited uncleanly during shutdown (code=${exitInfo.exitCode ?? "none"}, signal=${exitInfo.signalCode ?? "none"})`
+        );
+      }
+    } finally {
+      if (hardKillTimer) clearTimeout(hardKillTimer);
+      if (deadlineTimer) clearTimeout(deadlineTimer);
+    }
+  }
+};
+
 // packages/acp-bridge/src/spawnChannel.ts
 var cachedMemoryArgs;
 function getAcpMemoryArgs() {
@@ -178,6 +316,7 @@ function createStderrForwarder(opts) {
 }
 __name(createStderrForwarder, "createStderrForwarder");
 function createSpawnChannelFactory(options = {}) {
+  const processRegistry = options.processRegistry ?? new ProcessRegistry();
   return async (workspaceCwd, childEnvOverrides) => {
     const sourceEnv = options.sourceEnv ?? process.env;
     const cliEntry = sourceEnv["QWEN_CLI_ENTRY"] || process.argv[1];
@@ -194,21 +333,29 @@ function createSpawnChannelFactory(options = {}) {
     const execArgs = process.execArgv.filter(
       (a) => !/^--inspect(-brk)?($|=)/.test(a)
     );
-    const child = spawn(
-      process.execPath,
-      [
-        ...execArgs,
-        ...memoryArgs,
-        cliEntry,
-        "--acp",
-        ...options.extraArgs ?? []
-      ],
-      {
-        cwd: workspaceCwd,
-        stdio: ["pipe", "pipe", "pipe"],
-        env: childEnv
-      }
-    );
+    const reservation = processRegistry.reserve();
+    let child;
+    try {
+      child = spawn(
+        process.execPath,
+        [
+          ...execArgs,
+          ...memoryArgs,
+          cliEntry,
+          "--acp",
+          ...options.extraArgs ?? []
+        ],
+        {
+          cwd: workspaceCwd,
+          stdio: ["pipe", "pipe", "pipe"],
+          env: childEnv
+        }
+      );
+    } catch (error) {
+      reservation.cancel();
+      throw error;
+    }
+    const trackedChild = reservation.attach(child);
     if (child.stderr) {
       const prefix = `[serve pid=${child.pid} cwd=${workspaceCwd}] `;
       const forwarder = createStderrForwarder({
@@ -221,21 +368,8 @@ function createSpawnChannelFactory(options = {}) {
       child.stderr.on("error", () => {
       });
     }
-    const exited = new Promise((resolve) => {
-      let resolved = false;
-      const finish = /* @__PURE__ */ __name((info) => {
-        if (resolved) return;
-        resolved = true;
-        resolve(info);
-      }, "finish");
-      child.once(
-        "exit",
-        (code, signal) => finish({ exitCode: code, signalCode: signal })
-      );
-      child.once("error", () => finish(void 0));
-    });
     if (!child.stdin || !child.stdout) {
-      child.kill("SIGKILL");
+      trackedChild.killSync();
       throw new Error(
         "Spawned ACP child has no stdin/stdout \u2014 cannot establish NDJSON channel."
       );
@@ -245,22 +379,14 @@ function createSpawnChannelFactory(options = {}) {
     const stream = ndJsonStream(writable, readable, options.pipeHooks);
     return {
       stream,
-      kill: /* @__PURE__ */ __name(() => killChild(child), "kill"),
-      killSync: /* @__PURE__ */ __name(() => {
-        if (child.exitCode === null && child.signalCode === null) {
-          try {
-            child.kill("SIGKILL");
-          } catch {
-          }
-        }
-      }, "killSync"),
-      exited
+      kill: /* @__PURE__ */ __name(() => trackedChild.terminate(), "kill"),
+      killSync: /* @__PURE__ */ __name(() => trackedChild.killSync(), "killSync"),
+      exited: trackedChild.exited
     };
   };
 }
 __name(createSpawnChannelFactory, "createSpawnChannelFactory");
 var defaultSpawnChannelFactory = createSpawnChannelFactory();
-var KILL_HARD_DEADLINE_MS = 1e4;
 var SCRUBBED_CHILD_ENV_KEYS = /* @__PURE__ */ new Set([
   "QWEN_SERVER_TOKEN",
   "QWEN_CODE_SIMPLE"
@@ -283,46 +409,6 @@ function scrubChildEnv(source, scrubbed, overrides) {
   return childEnv;
 }
 __name(scrubChildEnv, "scrubChildEnv");
-function killChild(child) {
-  return new Promise((resolve) => {
-    if (child.exitCode !== null || child.signalCode !== null) {
-      resolve();
-      return;
-    }
-    let resolved = false;
-    const finish = /* @__PURE__ */ __name(() => {
-      if (resolved) return;
-      resolved = true;
-      child.removeListener("exit", finish);
-      resolve();
-    }, "finish");
-    child.once("exit", finish);
-    try {
-      child.kill("SIGTERM");
-    } catch {
-      finish();
-      return;
-    }
-    setTimeout(() => {
-      if (!resolved && child.exitCode === null && child.signalCode === null) {
-        try {
-          child.kill("SIGKILL");
-        } catch {
-        }
-      }
-    }, 5e3).unref();
-    setTimeout(() => {
-      if (!resolved) {
-        process.stderr.write(
-          `qwen serve: killChild hard deadline (${KILL_HARD_DEADLINE_MS}ms) reached; child pid=${child.pid} still alive (uninterruptible sleep?) \u2014 abandoning. Operator should check for zombie qwen --acp processes holding workspace resources.
-`
-        );
-        finish();
-      }
-    }, KILL_HARD_DEADLINE_MS).unref();
-  });
-}
-__name(killChild, "killChild");
 
 export {
   ndJsonStream,

package/chunks/{chunk-KMQ33DO4.js → chunk-KCO4FLFJ.js}

@@ -3,21 +3,21 @@
 import {
   resolveModelConfig,
   resolveProviderProtocol
-} from "./chunk-PHOF65IG.js";
+} from "./chunk-X5WNMMIA.js";
 import {
   external_exports
 } from "./chunk-H6XPXXMH.js";
 import {
   stripRuntimeSnapshotPrefix
-} from "./chunk-MZAXJAUM.js";
+} from "./chunk-BMFALVGQ.js";
 import {
   REASONING_EFFORT_TIERS,
   normalizeReasoningEffort
-} from "./chunk-XVNQMZ2I.js";
+} from "./chunk-DGEIYUC3.js";
 import {
   AuthType,
   MODEL_GENERATION_CONFIG_FIELDS
-} from "./chunk-IKCX4CCL.js";
+} from "./chunk-VCPIZRYH.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";