@ricsam/r5d-worker 0.0.136 → 0.0.138

package/dist/mjs/atomic-rename.mjs

@@ -1,261 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { randomUUID } from "node:crypto";
-class AtomicRenameError extends Error {
-  constructor(syscall, code, errno, path2, dest) {
-    super(`${code}: ${syscall} failed, ${path2} -> ${dest}`);
-    this.syscall = syscall;
-    this.code = code;
-    this.errno = errno;
-    this.path = path2;
-    this.dest = dest;
-    this.name = "AtomicRenameError";
-  }
-  syscall;
-  code;
-  errno;
-  path;
-  dest;
-}
-const UNSUPPORTED_CODES = /* @__PURE__ */ new Set(["EINVAL", "ENOSYS", "ENOTSUP", "EOPNOTSUPP", "EPERM"]);
-function isAtomicRenameUnsupported(error) {
-  return error instanceof AtomicRenameError && UNSUPPORTED_CODES.has(error.code);
-}
-const LINUX_AT_FDCWD = -100;
-const LINUX_RENAME_NOREPLACE = 1;
-const LINUX_RENAME_EXCHANGE = 2;
-const DARWIN_RENAME_SWAP = 2;
-const DARWIN_RENAME_EXCL = 4;
-const LINUX_SYS_RENAMEAT2 = { x64: 316, arm64: 276 };
-const PROBE_PREFIX = ".r5d-atomic-rename-probe-";
-let loaded = null;
-let override = null;
-const errnoNames = /* @__PURE__ */ new Map();
-for (const [name, value] of Object.entries(os.constants.errno)) errnoNames.set(value, name);
-function errnoCode(errno) {
-  return errnoNames.get(errno) ?? `E${errno}`;
-}
-function cString(value) {
-  return Buffer.from(`${value}\0`, "utf8");
-}
-function loadNative() {
-  if (loaded) return loaded;
-  loaded = { calls: null, detail: "not attempted" };
-  try {
-    const ffi = require("bun:ffi");
-    const { dlopen, FFIType, ptr, read } = ffi;
-    if (process.platform === "darwin") {
-      const lib = dlopen("libSystem.B.dylib", {
-        renamex_np: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32], returns: FFIType.i32 },
-        __error: { args: [], returns: FFIType.ptr }
-      });
-      loaded = {
-        calls: {
-          rename2: (from, to, flags) => {
-            const fromBuffer = cString(from);
-            const toBuffer = cString(to);
-            return lib.symbols.renamex_np(ptr(fromBuffer), ptr(toBuffer), flags);
-          },
-          errno: () => read.i32(lib.symbols.__error(), 0),
-          exchangeFlag: DARWIN_RENAME_SWAP,
-          noReplaceFlag: DARWIN_RENAME_EXCL,
-          backend: "renamex_np"
-        }
-      };
-      return loaded;
-    }
-    if (process.platform === "linux") {
-      const errnoLib = dlopen("libc.so.6", { __errno_location: { args: [], returns: FFIType.ptr } });
-      const errno = () => read.i32(errnoLib.symbols.__errno_location(), 0);
-      try {
-        const lib = dlopen("libc.so.6", {
-          renameat2: { args: [FFIType.i32, FFIType.ptr, FFIType.i32, FFIType.ptr, FFIType.u32], returns: FFIType.i32 }
-        });
-        loaded = {
-          calls: {
-            rename2: (from, to, flags) => {
-              const fromBuffer = cString(from);
-              const toBuffer = cString(to);
-              return lib.symbols.renameat2(LINUX_AT_FDCWD, ptr(fromBuffer), LINUX_AT_FDCWD, ptr(toBuffer), flags);
-            },
-            errno,
-            exchangeFlag: LINUX_RENAME_EXCHANGE,
-            noReplaceFlag: LINUX_RENAME_NOREPLACE,
-            backend: "renameat2"
-          }
-        };
-        return loaded;
-      } catch (error) {
-        const number = LINUX_SYS_RENAMEAT2[process.arch];
-        if (number === void 0) {
-          loaded = { calls: null, detail: `renameat2 symbol unavailable and no syscall number for ${process.arch}: ${String(error)}` };
-          return loaded;
-        }
-        const lib = dlopen("libc.so.6", {
-          syscall: {
-            args: [FFIType.i64, FFIType.i64, FFIType.i64, FFIType.i64, FFIType.i64, FFIType.i64],
-            returns: FFIType.i64
-          }
-        });
-        loaded = {
-          calls: {
-            rename2: (from, to, flags) => {
-              const fromBuffer = cString(from);
-              const toBuffer = cString(to);
-              return Number(
-                lib.symbols.syscall(number, LINUX_AT_FDCWD, Number(ptr(fromBuffer)), LINUX_AT_FDCWD, Number(ptr(toBuffer)), flags)
-              );
-            },
-            errno,
-            exchangeFlag: LINUX_RENAME_EXCHANGE,
-            noReplaceFlag: LINUX_RENAME_NOREPLACE,
-            backend: "syscall"
-          }
-        };
-        return loaded;
-      }
-    }
-    loaded = { calls: null, detail: `no atomic exchange primitive on ${process.platform}` };
-  } catch (error) {
-    loaded = { calls: null, detail: `bun:ffi unavailable: ${error instanceof Error ? error.message : String(error)}` };
-  }
-  return loaded;
-}
-function applyOverride(support) {
-  if (override?.exchange !== void 0) support.exchange = override.exchange;
-  if (override?.noReplace !== void 0) support.noReplace = override.noReplace;
-  return support;
-}
-function atomicRenameSupport() {
-  const native = loadNative();
-  return applyOverride(
-    native.calls ? { platform: process.platform, exchange: native.calls.backend, noReplace: native.calls.backend } : { platform: process.platform, exchange: "unavailable", noReplace: "link", detail: native.detail }
-  );
-}
-function overrideAtomicRenameSupportForTests(value) {
-  override = value;
-}
-function resetAtomicRenameProbesForTests() {
-  probes.clear();
-}
-function call(native, syscall, from, to, flags) {
-  if (native.rename2(from, to, flags) === 0) return;
-  const errno = native.errno();
-  throw new AtomicRenameError(syscall, errnoCode(errno), errno, from, to);
-}
-function exchangeWith(support, a, b) {
-  const native = loadNative().calls;
-  if (support.exchange === "unavailable" || !native) {
-    throw new AtomicRenameError("exchange", "ENOSYS", os.constants.errno.ENOSYS, a, b);
-  }
-  call(native, support.exchange, a, b, native.exchangeFlag);
-}
-function renameNoReplaceWith(support, from, to) {
-  const native = loadNative().calls;
-  if (support.noReplace !== "link" && native) {
-    call(native, support.noReplace, from, to, native.noReplaceFlag);
-    return;
-  }
-  const source = fs.lstatSync(from);
-  if (!source.isFile()) throw new AtomicRenameError("link", "ENOTSUP", os.constants.errno.ENOTSUP, from, to);
-  try {
-    fs.linkSync(from, to);
-  } catch (error) {
-    const code = error.code ?? "EIO";
-    throw new AtomicRenameError("link", code, error.errno ?? 0, from, to);
-  }
-  fs.unlinkSync(from);
-}
-function exchangePaths(a, b) {
-  exchangeWith(atomicRenameSupport(), a, b);
-}
-function renameNoReplace(from, to) {
-  renameNoReplaceWith(atomicRenameSupport(), from, to);
-}
-const probes = /* @__PURE__ */ new Map();
-function withoutTemporaries(directory, run) {
-  const token = randomUUID();
-  const a = path.join(directory, `${PROBE_PREFIX}${token}-a`);
-  const b = path.join(directory, `${PROBE_PREFIX}${token}-b`);
-  try {
-    run(a, b);
-  } finally {
-    fs.rmSync(a, { force: true });
-    fs.rmSync(b, { force: true });
-  }
-}
-function createProbeFile(filePath, content) {
-  const descriptor = fs.openSync(filePath, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL, 384);
-  try {
-    fs.writeSync(descriptor, content);
-    return fs.fstatSync(descriptor);
-  } finally {
-    fs.closeSync(descriptor);
-  }
-}
-function probeAtomicRenameSupport(directory) {
-  const native = atomicRenameSupport();
-  const dev = fs.lstatSync(directory).dev;
-  const cached = probes.get(dev);
-  if (cached) return applyOverride({ ...cached });
-  const probed = { ...native };
-  if (native.exchange !== "unavailable") {
-    withoutTemporaries(directory, (a, b) => {
-      const statA = createProbeFile(a, "a");
-      const statB = createProbeFile(b, "b");
-      let swapped = false;
-      let detail;
-      try {
-        exchangeWith(native, a, b);
-        const afterA = fs.lstatSync(a);
-        const afterB = fs.lstatSync(b);
-        swapped = afterA.ino === statB.ino && afterB.ino === statA.ino;
-        if (!swapped) detail = `exchange flag ignored by the filesystem holding ${directory}`;
-      } catch (error) {
-        detail = `exchange rejected by the filesystem holding ${directory}: ${error instanceof Error ? error.message : String(error)}`;
-      }
-      if (!swapped) {
-        probed.exchange = "unavailable";
-        probed.detail = detail;
-      }
-    });
-  }
-  if (native.noReplace !== "link") {
-    withoutTemporaries(directory, (a, b) => {
-      createProbeFile(a, "a");
-      createProbeFile(b, "b");
-      let refused = false;
-      try {
-        renameNoReplaceWith(native, a, b);
-      } catch (error) {
-        refused = error instanceof AtomicRenameError && error.code === "EEXIST";
-      }
-      if (!refused) {
-        probed.noReplace = "link";
-        probed.detail = `${probed.detail ? `${probed.detail}; ` : ""}no-replace flag ignored by the filesystem holding ${directory}`;
-      }
-    });
-  }
-  probes.set(dev, probed);
-  return applyOverride({ ...probed });
-}
-function atomicRenamePrimitivesFor(directory) {
-  const support = probeAtomicRenameSupport(directory);
-  return {
-    support,
-    exchange: (a, b) => exchangeWith(support, a, b),
-    renameNoReplace: (from, to) => renameNoReplaceWith(support, from, to)
-  };
-}
-export {
-  AtomicRenameError,
-  atomicRenamePrimitivesFor,
-  atomicRenameSupport,
-  exchangePaths,
-  isAtomicRenameUnsupported,
-  overrideAtomicRenameSupportForTests,
-  probeAtomicRenameSupport,
-  renameNoReplace,
-  resetAtomicRenameProbesForTests
-};

package/dist/mjs/browser-upload.mjs

@@ -1,42 +0,0 @@
-import fs from "node:fs/promises";
-import { constants } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import {
-  BROWSER_UPLOAD_CHUNK_BYTES,
-  validateUploadFile
-} from "@ricsam/r5d-api/browser-upload";
-async function readBrowserUploadChunk(input, context) {
-  if (typeof input.filePath !== "string" || !input.filePath.trim() || input.filePath.includes("\0"))
-    throw new Error("Upload requires a file path.");
-  if (!Number.isSafeInteger(input.offset) || input.offset < 0) throw new Error("Invalid upload read offset.");
-  if (input.offset > 0 && !input.version) throw new Error("Upload continuation requires a file version.");
-  const expanded = input.filePath.replace(/\$\{R5D_ROOT\}|\$R5D_ROOT\b/g, () => context.rootDir).replace(/\$\{R5D_SESSION_ID\}|\$R5D_SESSION_ID\b/g, () => context.sessionId).replace(/^~\//, () => `${os.homedir()}/`);
-  const filePath = path.resolve(context.cwd, expanded);
-  const handle = await fs.open(filePath, constants.O_RDONLY | constants.O_NONBLOCK);
-  try {
-    const stat = await handle.stat({ bigint: true });
-    if (!stat.isFile()) throw new Error(`Upload source is not a regular file: ${input.filePath}`);
-    const metadata = validateUploadFile({ filename: path.basename(filePath), size: Number(stat.size) });
-    const versionOf = (s) => `${s.dev}:${s.ino}:${s.size}:${s.mtimeNs}:${s.ctimeNs}`;
-    const version = versionOf(stat);
-    if (input.version !== void 0 && input.version !== version)
-      throw new Error(`Upload source changed while being transferred: ${input.filePath}`);
-    if (input.offset > metadata.size) throw new Error("Upload offset is past the end of the file.");
-    const bytes = Buffer.alloc(input.metadataOnly === true ? 0 : Math.min(BROWSER_UPLOAD_CHUNK_BYTES, metadata.size - input.offset));
-    let read = 0;
-    while (read < bytes.length) {
-      const { bytesRead } = await handle.read(bytes, read, bytes.length - read, input.offset + read);
-      if (!bytesRead) throw new Error(`Upload source was truncated: ${input.filePath}`);
-      read += bytesRead;
-    }
-    if (versionOf(await handle.stat({ bigint: true })) !== version)
-      throw new Error(`Upload source changed while being read: ${input.filePath}`);
-    return { type: "browser_upload_read", ...metadata, version, offset: input.offset, base64: bytes.toString("base64") };
-  } finally {
-    await handle.close();
-  }
-}
-export {
-  readBrowserUploadChunk
-};

package/dist/mjs/command-launcher.mjs

@@ -1,393 +0,0 @@
-import { spawn } from "node:child_process";
-function commandLaunchLane(request) {
-  if (request.commandClass === "control") {
-    if (request.kind !== "exec_start") throw new Error("Control commands must be exec_start launches");
-    return "control";
-  }
-  return request.kind === "exec" && request.workspaceEffect === "none" ? "utility" : "general";
-}
-class CommandLauncherUnavailableError extends Error {
-  constructor(message, cause) {
-    super(message, { cause });
-    this.name = "CommandLauncherUnavailableError";
-  }
-}
-class CommandLaunchCancelledError extends Error {
-  constructor() {
-    super("Command cancelled before it started");
-    this.name = "CommandLaunchCancelledError";
-  }
-}
-function parseCommandLauncher(configuration) {
-  if (configuration === void 0) return void 0;
-  let argv;
-  try {
-    argv = JSON.parse(configuration);
-  } catch {
-    throw new Error("R5D_WORKER_COMMAND_LAUNCHER must be a JSON argv array");
-  }
-  if (!Array.isArray(argv) || argv.length === 0 || argv.some((part) => typeof part !== "string" || part.includes("\0")) || !argv[0])
-    throw new Error("R5D_WORKER_COMMAND_LAUNCHER must be a nonempty JSON argv array without NUL characters");
-  return argv;
-}
-function commandLauncherEnvironment(source = process.env) {
-  const result = {};
-  for (const [key, value] of Object.entries(source)) {
-    if (/^(PATH|HOME|USER|LOGNAME|TMP|TMPDIR|TEMP|SHELL|SYSTEMROOT|COMSPEC|PATHEXT|LANG|LC_[A-Z_]+)$/i.test(key)) result[key] = value;
-  }
-  return result;
-}
-class WorkerCommandLauncher {
-  constructor(options = {}) {
-    this.options = options;
-    this.mode = options.argv ? "external" : "direct";
-    if (!options.argv) {
-      this.exited = Promise.resolve();
-      return;
-    }
-    this.child = spawn(options.argv[0], options.argv.slice(1), {
-      env: options.env ?? commandLauncherEnvironment(),
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    this.exited = new Promise((resolve) => {
-      this.child.once("close", (code, signal) => {
-        if (!this.closing) this.fail(new Error(`Configured command launcher exited (${signal ?? code ?? "unknown"})`));
-        resolve();
-      });
-    });
-    this.child.once("error", (error) => this.fail(error));
-    this.child.stdin.on("error", (error) => {
-      if (!this.closing) this.fail(error);
-    });
-    let buffered = "";
-    this.child.stdout.setEncoding("utf8");
-    this.child.stdout.on("data", (data) => {
-      buffered += data;
-      if (Buffer.byteLength(buffered) > 1024 * 1024) {
-        this.fail(new Error("Command launcher response exceeded the protocol limit"));
-        return;
-      }
-      while (buffered.includes("\n")) {
-        const newline = buffered.indexOf("\n");
-        const line = buffered.slice(0, newline);
-        buffered = buffered.slice(newline + 1);
-        try {
-          this.receive(JSON.parse(line));
-        } catch (error) {
-          this.fail(error instanceof Error ? error : new Error(String(error)));
-          return;
-        }
-      }
-    });
-    this.child.stderr.setEncoding("utf8");
-    this.child.stderr.on("data", (data) => options.onStderr?.(data));
-  }
-  options;
-  mode;
-  child;
-  pending = /* @__PURE__ */ new Map();
-  launches = /* @__PURE__ */ new Map();
-  exited;
-  failure;
-  closing = false;
-  initialized = false;
-  closePromise;
-  sequence = 0;
-  capacity;
-  async initialize() {
-    this.assertHealthy();
-    if (this.initialized) return;
-    if (this.child) {
-      try {
-        const result = await this.rpc("initialize");
-        this.capacity = parseCapacity(result.capacity);
-      } catch (error) {
-        this.fail(error instanceof Error ? error : new Error(String(error)));
-        await this.close();
-        throw error;
-      }
-    }
-    this.initialized = true;
-  }
-  get activeIds() {
-    return [...this.launches.keys()];
-  }
-  /** The lane totals the launcher declared at initialization; undefined for a direct worker or an older launcher. */
-  get declaredCapacity() {
-    return this.capacity;
-  }
-  get supportsControlLane() {
-    return this.initialized && (this.mode === "direct" || (this.capacity?.controlSlots ?? 0) > 0);
-  }
-  /** Current admissions per lane, for the worker's capacity report. */
-  capacityReport() {
-    const bounded = this.child !== void 0;
-    const lanes = {
-      general: { slots: bounded ? this.capacity?.generalSlots ?? null : null, active: [], queued: [] },
-      utility: { slots: bounded ? this.capacity?.utilitySlots ?? null : null, active: [], queued: [] },
-      control: { slots: bounded ? this.capacity?.controlSlots ?? null : null, active: [], queued: [] }
-    };
-    for (const record of this.launches.values()) {
-      if (record.released) continue;
-      const entry = {
-        id: record.request.id,
-        ...record.request.sessionId ? { sessionId: record.request.sessionId } : {},
-        since: record.since
-      };
-      (record.phase === "active" ? lanes[record.lane].active : lanes[record.lane].queued).push(entry);
-    }
-    return { bounded, controlRuntimeMs: bounded ? this.capacity?.controlRuntimeMs ?? null : null, lanes };
-  }
-  notifyCapacityChange() {
-    try {
-      this.options.onCapacityChange?.();
-    } catch {
-    }
-  }
-  async acquire(request) {
-    this.assertHealthy();
-    if (!this.initialized) throw new Error("Command launcher is not initialized");
-    request.assertAdmission();
-    if (this.launches.has(request.id)) throw new Error(`Duplicate command launch identity: ${request.id}`);
-    const lane = commandLaunchLane(request);
-    if (lane === "control" && !this.supportsControlLane)
-      throw new Error("Update the worker command launcher before running control commands");
-    let rejectAdmission;
-    const cancellation = new Promise((_resolve, reject) => {
-      rejectAdmission = reject;
-    });
-    void cancellation.catch(() => {
-    });
-    const record = {
-      request,
-      lane,
-      phase: this.child ? "queued" : "active",
-      since: (/* @__PURE__ */ new Date()).toISOString(),
-      revoked: false,
-      released: false,
-      rejectAdmission
-    };
-    this.launches.set(request.id, record);
-    this.notifyCapacityChange();
-    let prefix = [];
-    let admissionTimer;
-    try {
-      if (this.child) {
-        const { assertAdmission: _assertAdmission, ...fields } = request;
-        const acquisition = this.rpc("acquire", fields, this.options.acquisitionTimeoutMs ?? 9e4).then(async (result) => {
-          if (record.revoked) {
-            await this.releaseRecord(record);
-            throw new CommandLaunchCancelledError();
-          }
-          if (!Array.isArray(result.argvPrefix) || result.argvPrefix.some((part) => typeof part !== "string" || part.includes("\0")))
-            throw this.fail(new Error("Command launcher acquire returned an invalid argvPrefix"));
-          return result.argvPrefix;
-        });
-        admissionTimer = setInterval(() => {
-          try {
-            request.assertAdmission();
-          } catch (error) {
-            record.revoked = true;
-            record.rejectAdmission(error);
-            void this.cancel(request.id).catch(() => {
-            });
-          }
-        }, 100);
-        prefix = await Promise.race([acquisition, cancellation]);
-        record.phase = "active";
-        record.since = (/* @__PURE__ */ new Date()).toISOString();
-        this.notifyCapacityChange();
-      }
-      request.assertAdmission();
-      this.assertHealthy();
-      if (record.revoked) throw new CommandLaunchCancelledError();
-    } catch (error) {
-      if (!this.failure && !this.closing) await this.releaseRecord(record);
-      throw error;
-    } finally {
-      if (admissionTimer) clearInterval(admissionTimer);
-    }
-    return {
-      wrap: (argv) => {
-        this.assertHealthy();
-        request.assertAdmission();
-        if (record.revoked) throw new CommandLaunchCancelledError();
-        if (record.released) throw new Error("Command launch lease is already released");
-        if (!argv.length) throw new Error("Command argv must not be empty");
-        return [...prefix, ...argv];
-      },
-      cancel: async () => {
-        await this.cancel(request.id);
-      },
-      diagnose: async () => {
-        this.assertHealthy();
-        if (!this.child) return void 0;
-        try {
-          const result = await this.rpc("diagnose", { id: request.id });
-          if (result.message !== void 0 && typeof result.message !== "string")
-            throw new Error("Command launcher returned an invalid diagnostic");
-          return result.message;
-        } catch (error) {
-          throw this.fail(error instanceof Error ? error : new Error(String(error)));
-        }
-      },
-      release: () => this.releaseRecord(record)
-    };
-  }
-  /** Revoke a launch. Returns whether this launcher still held it (queued or acquired, not yet released). */
-  async cancel(id) {
-    const record = this.launches.get(id);
-    if (!record || record.released) return false;
-    record.revoked = true;
-    record.rejectAdmission(new CommandLaunchCancelledError());
-    if (this.child) {
-      try {
-        await this.rpc("cancel", { id });
-      } catch (error) {
-        throw this.fail(error instanceof Error ? error : new Error(String(error)));
-      }
-    }
-    return true;
-  }
-  async cancelSession(sessionId) {
-    await this.cancelMatching((_id, ownerSessionId) => ownerSessionId === sessionId);
-  }
-  async cancelMatching(matches) {
-    const results = await Promise.allSettled(
-      [...this.launches].filter(([id, record]) => matches(id, record.request.sessionId)).map(([id]) => this.cancel(id))
-    );
-    const errors = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
-    if (errors.length) throw new AggregateError(errors, "Command launcher cancellation was incomplete");
-  }
-  close() {
-    return this.closePromise ??= (async () => {
-      this.closing = true;
-      for (const record of this.launches.values()) {
-        record.revoked = true;
-        record.rejectAdmission(new CommandLaunchCancelledError());
-      }
-      this.rejectPending(new CommandLauncherUnavailableError("Command launcher is shutting down"));
-      this.child?.stdin.end();
-      const exited = await this.waitForExit(6e3);
-      if (!exited) {
-        this.child?.kill("SIGKILL");
-        await this.waitForExit(1e3);
-      }
-    })();
-  }
-  async waitForExit(timeoutMs) {
-    let timer;
-    try {
-      return await Promise.race([
-        this.exited.then(() => true),
-        new Promise((resolve) => {
-          timer = setTimeout(() => resolve(false), timeoutMs);
-        })
-      ]);
-    } finally {
-      if (timer) clearTimeout(timer);
-    }
-  }
-  releaseRecord(record) {
-    return record.release ??= (async () => {
-      record.revoked = true;
-      if (this.child) {
-        try {
-          await this.rpc("release", { id: record.request.id });
-        } catch (error) {
-          throw this.fail(error instanceof Error ? error : new Error(String(error)));
-        }
-      }
-      record.released = true;
-      this.launches.delete(record.request.id);
-      this.notifyCapacityChange();
-    })();
-  }
-  assertHealthy() {
-    if (this.failure) throw this.failure;
-    if (this.closing) throw new CommandLauncherUnavailableError("Command launcher is shutting down");
-  }
-  rpc(method, fields = {}, timeoutMs = this.options.requestTimeoutMs ?? 1e4) {
-    try {
-      this.assertHealthy();
-    } catch (error) {
-      return Promise.reject(error);
-    }
-    const requestId = String(++this.sequence);
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => this.fail(new Error(`Command launcher ${method} request timed out`)), timeoutMs);
-      this.pending.set(requestId, { resolve, reject, timer });
-      this.child.stdin.write(`${JSON.stringify({ requestId, method, ...fields })}
-`, (error) => {
-        if (error) this.fail(error);
-      });
-    });
-  }
-  receive(value) {
-    if (!value || typeof value !== "object") throw new Error("Invalid command launcher response");
-    const response = value;
-    if (typeof response.requestId !== "string") throw new Error("Command launcher response is missing requestId");
-    const request = this.pending.get(response.requestId);
-    if (!request) throw new Error("Command launcher returned an unknown requestId");
-    this.pending.delete(response.requestId);
-    clearTimeout(request.timer);
-    if (typeof response.error === "string") {
-      request.reject(new Error(response.error));
-      return;
-    }
-    if (!response.result || typeof response.result !== "object" || Array.isArray(response.result)) {
-      const error = new Error("Command launcher response is missing result");
-      request.reject(error);
-      throw error;
-    }
-    request.resolve(response.result);
-  }
-  rejectPending(error) {
-    for (const request of this.pending.values()) {
-      clearTimeout(request.timer);
-      request.reject(error);
-    }
-    this.pending.clear();
-  }
-  fail(error) {
-    if (this.failure || this.closing) return this.failure ?? error;
-    this.failure = new CommandLauncherUnavailableError(`Command launcher unavailable: ${error.message}`, error);
-    for (const record of this.launches.values()) {
-      record.revoked = true;
-      record.rejectAdmission(this.failure);
-    }
-    this.rejectPending(this.failure);
-    this.child?.kill("SIGTERM");
-    this.options.onFailure?.(this.failure, this.activeIds);
-    return this.failure;
-  }
-}
-function parseCapacity(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
-  const candidate = value;
-  const numbers = ["generalSlots", "utilitySlots", "controlSlots", "controlRuntimeMs", "queueTimeoutMs"];
-  if (!numbers.every((key) => typeof candidate[key] === "number" && Number.isSafeInteger(candidate[key]) && candidate[key] >= 0)) {
-    throw new Error("Command launcher initialize returned an invalid capacity");
-  }
-  return {
-    generalSlots: candidate.generalSlots,
-    utilitySlots: candidate.utilitySlots,
-    controlSlots: candidate.controlSlots,
-    controlRuntimeMs: candidate.controlRuntimeMs,
-    queueTimeoutMs: candidate.queueTimeoutMs
-  };
-}
-async function createWorkerCommandLauncher(options = {}) {
-  const launcher = new WorkerCommandLauncher({ ...options, argv: parseCommandLauncher(options.configuration) });
-  await launcher.initialize();
-  return launcher;
-}
-export {
-  CommandLaunchCancelledError,
-  CommandLauncherUnavailableError,
-  WorkerCommandLauncher,
-  commandLaunchLane,
-  commandLauncherEnvironment,
-  createWorkerCommandLauncher,
-  parseCommandLauncher
-};