@smthrs/platform-node 0.0.0-stage → 1.0.0-rc.4

package/dist/cjs/internal/ProcessSupervisor.js

@@ -0,0 +1,685 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ProcessSupervisor_exports = {};
+__export(ProcessSupervisor_exports, {
+  Control: () => Control,
+  bootstrapArguments: () => bootstrapArguments,
+  connectOwner: () => connectOwner,
+  failure: () => failure,
+  prepare: () => prepare,
+  targetPidOf: () => targetPidOf,
+  unverifiedCleanup: () => unverifiedCleanup
+});
+module.exports = __toCommonJS(ProcessSupervisor_exports);
+var Channel = __toESM(require("effect/Channel"), 1);
+var Clock = __toESM(require("effect/Clock"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var PlatformError = __toESM(require("effect/PlatformError"), 1);
+var Sink = __toESM(require("effect/Sink"), 1);
+var Stream = __toESM(require("effect/Stream"), 1);
+var ChildProcess = __toESM(require("effect/unstable/process/ChildProcess"), 1);
+var import_ChildProcessSpawner = require("effect/unstable/process/ChildProcessSpawner");
+var import_node_crypto = require("node:crypto");
+var import_node_fs = require("node:fs");
+var import_node_net = require("node:net");
+var import_node_os = require("node:os");
+var import_node_path = require("node:path");
+var Tls = __toESM(require("node:tls"), 1);
+var import_PipedProcess = require("./PipedProcess.js");
+var import_ProcessFault = require("./ProcessFault.js");
+var import_SupervisorProgram = require("./SupervisorProgram.js");
+var import_WindowsProcessJob = require("./WindowsProcessJob.js");
+const startupMs = 5e3;
+const deliveryMs = 500;
+const exitAllowanceMs = 2500;
+const verificationMs = 2500;
+const targets = /* @__PURE__ */ new WeakMap();
+const processClock = Clock.Clock.defaultValue();
+const targetPidOf = (handle) => targets.get(handle)?.targetPid;
+const nativeError = (cause) => {
+  if (cause instanceof Error) return cause;
+  const value = cause ?? {};
+  const text = (field) => typeof value[field] === "string" ? value[field] : void 0;
+  return new import_ProcessFault.NativeProcessError({
+    message: text("message") ?? "The process supervisor failed",
+    code: text("code"),
+    errno: typeof value.errno === "number" ? value.errno : void 0,
+    reason: text("reason"),
+    syscall: text("syscall"),
+    path: text("path"),
+    signal: text("signal")
+  });
+};
+const failure = (method, command, cause) => {
+  const error = nativeError(cause);
+  const tags = {
+    ENOENT: "NotFound",
+    EACCES: "PermissionDenied",
+    EEXIST: "AlreadyExists",
+    EISDIR: "BadResource",
+    ENOTDIR: "BadResource",
+    ELOOP: "BadResource",
+    EBUSY: "Busy"
+  };
+  return PlatformError.systemError({
+    _tag: tags[error.code ?? ""] ?? "Unknown",
+    module: "ChildProcess",
+    method,
+    pathOrDescriptor: command,
+    syscall: error.syscall,
+    description: error.message,
+    cause: error
+  });
+};
+const unverifiedCleanup = (control, cleanupRequired, vacant, observed) => [
+  `target exited: ${control.targetDone}`,
+  `cleanup receipt: ${control.cleanupFailed ? "failed" : !cleanupRequired ? "not required" : control.cleanupAcknowledged ? "acknowledged" : "missing"}`,
+  `group vacant: ${vacant}`,
+  observed === void 0 ? "group snapshot: unavailable" : `group members: ${observed.members.length === 0 ? "none" : observed.members.map((member) => `${member.pid} ${member.zombie ? "zombie" : "live"}`).join(", ")}; host group ${observed.ownGroup}`,
+  ...control.fault === void 0 ? [] : [`fault: ${String(control.fault?.message ?? control.fault)}`]
+].join("; ");
+const promise = () => {
+  let resolve2;
+  let reject;
+  const promise2 = new Promise((yes, no) => {
+    resolve2 = yes;
+    reject = no;
+  });
+  void promise2.catch(() => {
+  });
+  return { promise: promise2, resolve: resolve2, reject };
+};
+const wait = (value, method, command) => Effect.tryPromise({ try: () => value, catch: (cause) => failure(method, command, cause) });
+const bounded = (effect, millis, method, command) => effect.pipe(
+  Effect.timeoutOrElse({
+    duration: millis,
+    orElse: () => Effect.fail(
+      failure(method, command, (0, import_ProcessFault.processFault)("supervisor_timeout", `Process supervisor ${method} timed out`))
+    )
+  }),
+  Effect.provideService(Clock.Clock, processClock)
+);
+const bootstrapArguments = (runtime) => runtime.sea || runtime.main.startsWith("/$bunfs/") ? Effect.fail(
+  failure(
+    "spawn",
+    process.execPath,
+    (0, import_ProcessFault.processFault)(
+      "runtime_unsupported",
+      "Process supervision requires a Node or Bun runtime executable, not a compiled application"
+    )
+  )
+) : Effect.succeed(runtime.bun ? ["--no-env-file", "--config=/dev/null"] : []);
+const channelEnvironment = "SMITHERS_PROCESS_CHANNEL";
+const tlsOptions = { minVersion: "TLSv1.3", maxVersion: "TLSv1.3", ciphers: "TLS_AES_128_GCM_SHA256" };
+const connectOwner = (path, environment) => {
+  const encoded = environment[channelEnvironment];
+  if (encoded === void 0) return (0, import_node_net.createConnection)(path);
+  const channel = JSON.parse(encoded);
+  return Tls.connect({
+    ...tlsOptions,
+    host: "127.0.0.1",
+    port: path.endsWith("/r") ? channel.requests : channel.status,
+    pskCallback: () => ({ identity: "smithers-owner", psk: Buffer.from(channel.key, "hex") })
+  });
+};
+class Control {
+  ready = promise();
+  started = promise();
+  exited = promise();
+  lost = promise();
+  ended = promise();
+  requestsReady = promise();
+  directory;
+  path;
+  requestPath;
+  server;
+  requestServer;
+  listening;
+  key;
+  connections = /* @__PURE__ */ new Set();
+  socket;
+  requestSocket;
+  targetDone = false;
+  ownerCreation;
+  targetPid;
+  /** The owner's group guardian: a member that is neither target nor owner. */
+  guardianPid;
+  ownerDone = false;
+  spawnFailed = false;
+  cleanupFailed = false;
+  cleanupAcknowledged = false;
+  activationSent = false;
+  closeSent = false;
+  fault;
+  onTargetExit = () => {
+  };
+  onCleanup = () => {
+  };
+  receivedReady = false;
+  receivedStarted = false;
+  withdrawn = false;
+  constructor(transport = "native") {
+    this.key = transport === "tls" || process.platform === "win32" ? (0, import_node_crypto.randomBytes)(32) : void 0;
+    this.directory = (0, import_node_fs.mkdtempSync)(this.key === void 0 ? "/tmp/sm-p-" : (0, import_node_path.join)((0, import_node_os.tmpdir)(), "sm-p-"));
+    this.path = `${this.directory}/s`;
+    this.requestPath = `${this.directory}/r`;
+    const servers = [];
+    try {
+      (0, import_node_fs.chmodSync)(this.directory, 448);
+      this.server = this.makeServer((socket) => this.accept(socket));
+      servers.push(this.server);
+      this.requestServer = this.makeServer((socket) => this.acceptRequests(socket));
+      servers.push(this.requestServer);
+      this.listening = Promise.all([
+        new Promise((resolve2, reject) => {
+          this.server.once("error", reject);
+          if (this.key === void 0) this.server.listen(this.path, resolve2);
+          else this.server.listen(0, "127.0.0.1", resolve2);
+        }),
+        new Promise((resolve2, reject) => {
+          this.requestServer.once("error", reject);
+          if (this.key === void 0) this.requestServer.listen(this.requestPath, resolve2);
+          else this.requestServer.listen(0, "127.0.0.1", resolve2);
+        })
+      ]).then(() => {
+      });
+    } catch (cause) {
+      for (const server of servers) server.close();
+      (0, import_node_fs.rmSync)(this.directory, { recursive: true, force: true });
+      throw cause;
+    }
+  }
+  makeServer(accept) {
+    if (this.key === void 0) return (0, import_node_net.createServer)(accept);
+    const server = Tls.createServer({
+      ...tlsOptions,
+      handshakeTimeout: startupMs,
+      pskCallback: (_socket, identity) => identity === "smithers-owner" ? this.key : null
+    }, accept);
+    server.on("connection", (socket) => {
+      this.connections.add(socket);
+      socket.once("close", () => this.connections.delete(socket));
+    });
+    server.on("tlsClientError", (_error, socket) => socket.destroy());
+    return server;
+  }
+  /** Only the trusted owner receives this environment; target configuration replaces it. */
+  environment() {
+    if (this.key === void 0) return {};
+    const status = this.server.address();
+    const requests = this.requestServer.address();
+    return {
+      [channelEnvironment]: JSON.stringify({
+        key: this.key.toString("hex"),
+        status: status.port,
+        requests: requests.port
+      })
+    };
+  }
+  /** The test peer uses the same authenticated transport as the isolated owner. */
+  connect(requests = false) {
+    return connectOwner(requests ? this.requestPath : this.path, this.environment());
+  }
+  /** Validate the stored READY after the raw spawn effect has returned its pid. */
+  withdraw(pid, actual) {
+    if (pid !== actual) throw (0, import_ProcessFault.processFault)("identity_mismatch", "Wrong supervisor identity");
+    this.server.close();
+    this.server.unref();
+    this.requestServer.close();
+    this.requestServer.unref();
+    (0, import_node_fs.rmSync)(this.path, { force: true });
+    (0, import_node_fs.rmSync)(this.requestPath, { force: true });
+    (0, import_node_fs.rmdirSync)(this.directory);
+    this.withdrawn = true;
+  }
+  /** Request EOF asks for cleanup; leave its independent status reader intact. */
+  disconnect() {
+    this.requestSocket?.destroy();
+  }
+  dispose() {
+    for (const socket of this.connections) socket.destroy();
+    this.disconnect();
+    this.socket?.destroy();
+    this.server.close();
+    this.requestServer.close();
+    if (!this.withdrawn) (0, import_node_fs.rmSync)(this.directory, { recursive: true, force: true });
+  }
+  rawEnded() {
+    this.ownerDone = true;
+    if (this.socket === void 0) this.closed();
+  }
+  write(message) {
+    return new Promise((resolve2, reject) => {
+      const socket = this.requestSocket;
+      if (socket === void 0 || socket.destroyed || !socket.writable) {
+        reject((0, import_ProcessFault.processFault)("control_channel_closed", "Private process control channel closed"));
+        return;
+      }
+      const data = `${JSON.stringify(message)}
+`;
+      if (Buffer.byteLength(data) > 4 * 1024 * 1024) {
+        reject((0, import_ProcessFault.processFault)("configuration_too_large", "Process configuration exceeds the private frame limit"));
+        return;
+      }
+      socket.write(data, (error) => error ? reject(error) : resolve2());
+    });
+  }
+  closed() {
+    this.disconnect();
+    const cause = this.fault ?? (0, import_ProcessFault.processFault)("outcome_missing", "Process supervisor closed before reporting its outcome");
+    if (this.activationSent && !this.targetDone && !this.spawnFailed) this.lost.reject(cause);
+    this.ready.reject(cause);
+    this.requestsReady.reject(cause);
+    this.started.reject(cause);
+    this.exited.reject(cause);
+    this.ended.resolve();
+  }
+  acceptRequests(socket) {
+    if (this.requestSocket !== void 0) {
+      socket.destroy();
+      return;
+    }
+    this.requestSocket = socket;
+    socket.on("error", (cause) => {
+      this.fault = cause;
+    });
+    this.requestsReady.resolve();
+  }
+  accept(socket) {
+    if (this.socket !== void 0) {
+      socket.destroy();
+      return;
+    }
+    this.socket = socket;
+    let buffer = "";
+    socket.setEncoding("utf8");
+    socket.on("data", (data) => {
+      try {
+        buffer += data;
+        if (Buffer.byteLength(buffer) > 16 * 1024) {
+          throw (0, import_ProcessFault.processFault)("status_too_large", "Process status frame exceeds its limit");
+        }
+        for (; ; ) {
+          const end = buffer.indexOf("\n");
+          if (end < 0) break;
+          const line = buffer.slice(0, end);
+          buffer = buffer.slice(end + 1);
+          this.receive(JSON.parse(line));
+        }
+      } catch (cause) {
+        this.fault = cause;
+        socket.destroy();
+      }
+    });
+    socket.on("error", (cause) => {
+      this.fault = cause;
+    });
+    socket.once("close", () => this.closed());
+  }
+  receive(value) {
+    if (typeof value !== "object" || value === null) throw (0, import_ProcessFault.processFault)("status_invalid", "Invalid process status");
+    const message = value;
+    switch (message.type) {
+      case "ready":
+        if (this.receivedReady || message.version !== 1 || !Number.isSafeInteger(message.pid) || Number(message.pid) <= 1) {
+          throw (0, import_ProcessFault.processFault)("status_invalid", "Invalid process readiness");
+        }
+        this.receivedReady = true;
+        this.ownerCreation = message.created;
+        this.ready.resolve(Number(message.pid));
+        return;
+      case "spawned":
+        if (!this.activationSent || this.receivedStarted || !Number.isSafeInteger(message.pid) || Number(message.pid) <= 1 || message.guardian !== void 0 && (!Number.isSafeInteger(message.guardian) || Number(message.guardian) <= 1)) {
+          throw (0, import_ProcessFault.processFault)("status_invalid", "Invalid target startup");
+        }
+        this.receivedStarted = true;
+        this.targetPid = Number(message.pid);
+        if (message.guardian !== void 0) this.guardianPid = Number(message.guardian);
+        this.started.resolve();
+        return;
+      case "spawn_error":
+        if (!this.activationSent || this.receivedStarted) {
+          throw (0, import_ProcessFault.processFault)("status_invalid", "Invalid target spawn failure");
+        }
+        this.spawnFailed = true;
+        this.fault = message;
+        this.started.reject(message);
+        this.exited.reject(message);
+        return;
+      case "fault":
+        this.fault = message;
+        this.started.reject(message);
+        this.exited.reject(message);
+        return;
+      case "exit":
+        if (!this.receivedStarted || this.targetDone || !(Number.isInteger(message.code) && Number(message.code) >= 0 && message.signal === null || message.code === null && typeof message.signal === "string" && /^SIG[A-Z0-9]+$/.test(message.signal))) {
+          throw (0, import_ProcessFault.processFault)("status_invalid", "Invalid target exit status");
+        }
+        this.targetDone = true;
+        if (message.code === null) {
+          this.exited.reject({
+            message: `Process interrupted due to receipt of signal: '${message.signal}'`,
+            signal: message.signal
+          });
+        } else this.exited.resolve((0, import_ChildProcessSpawner.ExitCode)(Number(message.code)));
+        this.onTargetExit();
+        return;
+      case "cleanup_error":
+        this.cleanupFailed = true;
+        this.fault = message;
+        return;
+      case "cleanup":
+        this.cleanupAcknowledged = true;
+        this.onCleanup();
+        return;
+      default:
+        throw (0, import_ProcessFault.processFault)("status_unknown", "Unknown process status");
+    }
+  }
+}
+const prepare = (system, policy, transport = "native") => (command, spawn) => Effect.gen(function* () {
+  const initial = yield* policy(command.options);
+  const bun = process.versions.bun !== void 0;
+  const sea = bun ? false : (yield* Effect.tryPromise({
+    try: () => import("node:sea"),
+    catch: (cause) => failure("spawn", process.execPath, cause)
+  })).isSea();
+  const bootstrap = yield* bootstrapArguments({
+    bun,
+    sea,
+    main: globalThis.Bun?.main ?? ""
+  });
+  const windows = system.platform === "win32";
+  const grouped = !windows && (command.options.detached ?? true);
+  const jobExecutable = windows ? yield* Effect.try({
+    try: import_WindowsProcessJob.resolveJobExecutable,
+    catch: (cause) => failure("spawn", command.command, cause)
+  }) : void 0;
+  const control = yield* Effect.acquireRelease(
+    Effect.try({ try: () => new Control(transport), catch: (cause) => failure("spawn", command.command, cause) }),
+    (control2) => Effect.sync(() => control2.dispose())
+  );
+  yield* bounded(wait(control.listening, "spawn", command.command), startupMs, "spawn", command.command);
+  const raw = yield* spawn(ChildProcess.make(process.execPath, [
+    ...bootstrap,
+    "-e",
+    import_SupervisorProgram.source,
+    control.path,
+    grouped ? "group" : "direct"
+  ], {
+    ...command.options,
+    cwd: (0, import_node_path.parse)(process.execPath).root,
+    env: {
+      PATH: "/usr/bin:/bin",
+      HOME: "/",
+      XDG_CONFIG_HOME: "/",
+      BUN_RUNTIME_TRANSPILER_CACHE_PATH: "0",
+      ...control.environment(),
+      ...jobExecutable === void 0 ? {} : { SMITHERS_PROCESS_JOB_HELPER: jobExecutable }
+    },
+    extendEnv: false,
+    shell: false,
+    detached: grouped,
+    killSignal: "SIGTERM",
+    forceKillAfter: initial.graceMs
+  }));
+  yield* Effect.exit(raw.exitCode).pipe(Effect.andThen(Effect.sync(() => control.rawEnded())), Effect.forkScoped);
+  let job;
+  let settled = false;
+  let referenced = true;
+  let reref = Effect.void;
+  let selected = initial;
+  let requireCleanupReceipt = false;
+  const snapshot = () => system.snapshot(raw.pid);
+  const alone = () => {
+    if (!grouped) return control.targetDone;
+    const observed = snapshot();
+    if (observed === void 0 || observed.ownGroup === raw.pid) return false;
+    const running = observed.members.filter((member) => !member.zombie && member.pid !== control.guardianPid);
+    return running.length === 1 && running[0].pid === raw.pid;
+  };
+  control.onTargetExit = () => {
+    if (control.closeSent) return;
+    if (!alone()) return;
+    control.closeSent = true;
+    void control.write({ type: "stop", killSignal: "SIGKILL", fast: true }).catch(() => control.disconnect());
+  };
+  const finish = yield* Effect.cached(Effect.gen(function* () {
+    yield* bounded(Effect.exit(raw.exitCode), selected.graceMs + exitAllowanceMs, "kill", command.command).pipe(
+      Effect.catch(
+        (cause) => job === void 0 ? Effect.fail(cause) : Effect.gen(function* () {
+          job.stop();
+          yield* bounded(Effect.exit(raw.exitCode), exitAllowanceMs, "kill", command.command);
+        })
+      )
+    );
+    if (job !== void 0) {
+      yield* bounded(wait(job.settled.promise, "kill", command.command), 5500, "kill", command.command);
+      settled = true;
+      return;
+    }
+    yield* bounded(wait(control.ended.promise, "kill", command.command), deliveryMs, "kill", command.command).pipe(
+      Effect.ignore
+    );
+    const deadline = Date.now() + verificationMs;
+    for (; ; ) {
+      const vacant = grouped && system.vacant(raw.pid);
+      const observed = grouped && !vacant ? snapshot() : void 0;
+      settled = !control.cleanupFailed && (!requireCleanupReceipt || control.cleanupAcknowledged) && (grouped ? vacant || observed !== void 0 && observed.ownGroup !== raw.pid && observed.members.every((member) => member.zombie) : control.targetDone || control.spawnFailed || !control.activationSent);
+      if (settled) return;
+      if (Date.now() >= deadline) {
+        return yield* Effect.fail(
+          failure(
+            "kill",
+            command.command,
+            (0, import_ProcessFault.processFault)(
+              "cleanup_unverified",
+              `Process cleanup could not be verified; its ledger record is retained (${unverifiedCleanup(control, requireCleanupReceipt, vacant, observed)})`,
+              {
+                cause: {
+                  fault: control.fault,
+                  cleanupFailed: control.cleanupFailed,
+                  cleanupRequired: requireCleanupReceipt,
+                  cleanupAcknowledged: control.cleanupAcknowledged,
+                  targetDone: control.targetDone,
+                  groupVacant: vacant,
+                  ownerObserved: observed !== void 0,
+                  members: observed?.members
+                }
+              }
+            )
+          )
+        );
+      }
+      yield* Effect.sleep(10).pipe(Effect.provideService(Clock.Clock, processClock));
+    }
+  }));
+  const kill = (options2 = {}) => Effect.gen(function* () {
+    const requested = yield* policy(options2, command.options);
+    if (!referenced) {
+      job?.reference(true);
+      control.socket?.ref();
+      control.requestSocket?.ref();
+      yield* reref;
+      referenced = true;
+    }
+    if (!control.closeSent) {
+      control.closeSent = true;
+      selected = requested;
+      requireCleanupReceipt = grouped && control.activationSent && !control.spawnFailed && !control.targetDone;
+      yield* bounded(
+        wait(
+          control.write({
+            type: "stop",
+            explicit: true,
+            ...requested,
+            // A live target can move out of this group with setsid().
+            // Only an owner whose target was never activated can replace
+            // the requested signal; natural exit has its own fast path.
+            killSignal: !control.activationSent && alone() ? "SIGKILL" : requested.killSignal
+          }),
+          "kill",
+          command.command
+        ),
+        deliveryMs,
+        "kill",
+        command.command
+      ).pipe(Effect.catch(() => Effect.sync(() => control.disconnect())));
+    }
+    yield* finish;
+  }).pipe(Effect.uninterruptible);
+  yield* Effect.addFinalizer(
+    () => kill().pipe(
+      // A stuck owner keeps its ledger entry. Disable the underlying spawner's
+      // unconditional group-kill finalizer rather than signal a stale identity.
+      Effect.ensuring(
+        Effect.suspend(
+          () => settled ? Effect.void : Effect.andThen(
+            raw.unref,
+            Effect.sync(() => {
+              job?.stop();
+              job?.reference(false);
+              control.disconnect();
+            })
+          )
+        ).pipe(Effect.orDie)
+      ),
+      Effect.orDie
+    )
+  );
+  const ready = yield* bounded(
+    wait(control.ready.promise, "spawn", command.command),
+    startupMs,
+    "spawn",
+    command.command
+  );
+  yield* bounded(wait(control.requestsReady.promise, "spawn", command.command), startupMs, "spawn", command.command);
+  yield* Effect.try({
+    try: () => control.withdraw(ready, raw.pid),
+    catch: (cause) => failure("spawn", command.command, cause)
+  });
+  if (windows) {
+    job = yield* Effect.try({
+      try: () => new import_WindowsProcessJob.WindowsProcessJob(raw.pid, control.ownerCreation, jobExecutable),
+      catch: (cause) => failure("spawn", command.command, cause)
+    });
+    yield* bounded(wait(job.ready.promise, "spawn", command.command), startupMs, "spawn", command.command);
+  }
+  const acknowledgeCleanup = windows || transport === "tls";
+  if (acknowledgeCleanup) {
+    control.onCleanup = () => {
+      if (!control.ownerDone) {
+        void control.write({ type: "cleanup_ack" }).catch(() => control.disconnect());
+      }
+    };
+  }
+  const options = command.options;
+  const env = options.extendEnv ? { ...process.env, ...options.env } : options.env ?? { ...process.env };
+  yield* bounded(
+    wait(
+      control.write({
+        type: "configure",
+        acknowledgeCleanup,
+        command: command.command,
+        args: command.args,
+        cwd: (0, import_node_path.resolve)(options.cwd ?? process.cwd()),
+        env,
+        shell: options.shell,
+        windowsHide: options.windowsHide ?? true,
+        windowsVerbatimArguments: options.windowsVerbatimArguments,
+        standardFds: (0, import_PipedProcess.standardFdsOf)(raw),
+        userFds: [
+          ...new Set(
+            Object.keys(options.additionalFds ?? {}).map(ChildProcess.parseFdName).filter((fd) => fd !== void 0)
+          )
+        ],
+        ...initial
+      }),
+      "spawn",
+      command.command
+    ),
+    deliveryMs,
+    "spawn",
+    command.command
+  );
+  const activate = yield* Effect.cached(Effect.gen(function* () {
+    control.activationSent = true;
+    yield* bounded(
+      wait(control.write({ type: "start" }), "spawn", command.command),
+      deliveryMs,
+      "spawn",
+      command.command
+    );
+    yield* bounded(wait(control.started.promise, "spawn", command.command), startupMs, "spawn", command.command);
+  }));
+  const unref = Effect.gen(function* () {
+    if (referenced) {
+      reref = yield* raw.unref;
+      job?.reference(false);
+      control.socket?.unref();
+      control.requestSocket?.unref();
+      referenced = false;
+    }
+    return Effect.gen(function* () {
+      if (!referenced) {
+        job?.reference(true);
+        control.socket?.ref();
+        control.requestSocket?.ref();
+        yield* reref;
+        referenced = true;
+      }
+    });
+  });
+  const output = (stream) => stream.pipe(
+    Stream.interruptWhen(wait(control.lost.promise, "read", command.command))
+  );
+  const input = (sink) => Sink.fromChannel(
+    Sink.toChannel(sink).pipe(Channel.interruptWhen(wait(control.lost.promise, "write", command.command)))
+  );
+  const handle = (0, import_ChildProcessSpawner.makeHandle)({
+    ...raw,
+    exitCode: wait(control.exited.promise, "exitCode", command.command),
+    isRunning: Effect.sync(() => !control.targetDone && !control.ownerDone),
+    stdin: input(raw.stdin),
+    getInputFd: (fd) => input(raw.getInputFd(fd)),
+    stdout: output(raw.stdout),
+    stderr: output(raw.stderr),
+    all: output(raw.all),
+    getOutputFd: (fd) => output(raw.getOutputFd(fd)),
+    kill,
+    unref
+  });
+  targets.set(handle, control);
+  return {
+    handle,
+    activate,
+    settled: Effect.sync(() => settled)
+  };
+});
+//# sourceMappingURL=ProcessSupervisor.js.map