import * as Duration from "effect/Duration";import * as Effect from "effect/Effect";import * as Exit from "effect/Exit";import * as Layer from "effect/Layer";import * as Scope from "effect/Scope";import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"; export type ChildProcessShutdownSignal = "SIGTERM" | "SIGKILL"; export interface BoundedChildProcessSpawnerOptions {  readonly termGraceMs?: number;  readonly killGraceMs?: number;  readonly pollIntervalMs?: number;} const DEFAULT_TERM_GRACE_MS = 2_000;const DEFAULT_KILL_GRACE_MS = 1_000;const DEFAULT_POLL_INTERVAL_MS = 25; const normalizedDelay = (value: number | undefined, fallback: number) =>  value === undefined || !Number.isFinite(value) ? fallback : Math.max(0, value); const isStillRunning = (handle: ChildProcessSpawner.ChildProcessHandle) =>  handle.isRunning.pipe(Effect.orElseSucceed(() => true)); const waitUntilStopped = Effect.fn("BoundedChildProcessSpawner.waitUntilStopped")(function* (  handle: ChildProcessSpawner.ChildProcessHandle,  timeoutMs: number,  pollIntervalMs: number,) {  let remainingMs = timeoutMs;   while (yield* isStillRunning(handle)) {    if (remainingMs <= 0) return false;    const delayMs = Math.min(pollIntervalMs, remainingMs);    yield* Effect.sleep(delayMs);    remainingMs -= delayMs;  }   return true;}); const closeScopeDetached = Effect.fn("BoundedChildProcessSpawner.closeScopeDetached")(function* (  scope: Scope.Closeable,) {  yield* Scope.close(scope, Exit.void).pipe(    Effect.ignoreCause({ log: true }),    Effect.forkDetach({ startImmediately: true }),  );}); export const make = (  delegate: ChildProcessSpawner.ChildProcessSpawner["Service"],  options: BoundedChildProcessSpawnerOptions = {},) => {  const termGraceMs = normalizedDelay(options.termGraceMs, DEFAULT_TERM_GRACE_MS);  const killGraceMs = normalizedDelay(options.killGraceMs, DEFAULT_KILL_GRACE_MS);  const pollIntervalMs = Math.max(    1,    normalizedDelay(options.pollIntervalMs, DEFAULT_POLL_INTERVAL_MS),  );  const sendSignal = Effect.fn("BoundedChildProcessSpawner.sendSignal")(function* (    handle: ChildProcessSpawner.ChildProcessHandle,    signal: ChildProcess.Signal,  ) {    yield* handle      .kill({ killSignal: signal })      .pipe(Effect.ignore, Effect.forkDetach({ startImmediately: true }));  });   const kill = Effect.fn("BoundedChildProcessSpawner.kill")(function* (    handle: ChildProcessSpawner.ChildProcessHandle,    killOptions?: ChildProcess.KillOptions,  ) {    if (!(yield* isStillRunning(handle))) return;     const initialSignal = killOptions?.killSignal ?? "SIGTERM";    const initialGraceMs =      initialSignal === "SIGKILL"        ? killGraceMs        : Math.min(            termGraceMs,            normalizedDelay(              killOptions?.forceKillAfter === undefined                ? undefined                : Duration.toMillis(killOptions.forceKillAfter),              termGraceMs,            ),          );    yield* sendSignal(handle, initialSignal);    const stoppedAfterInitialSignal = yield* waitUntilStopped(      handle,      initialGraceMs,      pollIntervalMs,    );    if (stoppedAfterInitialSignal) return;     if (initialSignal !== "SIGKILL") {      yield* sendSignal(handle, "SIGKILL");      if (yield* waitUntilStopped(handle, killGraceMs, pollIntervalMs)) return;    }     yield* Effect.logWarning("Child process did not stop after SIGKILL grace period", {      pid: Number(handle.pid),      killGraceMs,    });  });   const shutdown = Effect.fn("BoundedChildProcessSpawner.shutdown")(function* (    handle: ChildProcessSpawner.ChildProcessHandle,    childScope: Scope.Closeable,    isReferenced: () => boolean,  ) {    if (isReferenced()) {      yield* kill(handle);    }     // The platform spawner's own finalizer can wait forever for an exit event.    // Run it detached so it can finish normally without blocking the caller's    // scope when the operating system does not report an exit in time.    yield* closeScopeDetached(childScope);  });   const spawn = Effect.fn("BoundedChildProcessSpawner.spawn")(function* (    command: ChildProcess.Command,  ) {    const childScope = yield* Scope.make("sequential");    const spawned = yield* delegate      .spawn(command)      .pipe(Effect.provideService(Scope.Scope, childScope), Effect.exit);     if (Exit.isFailure(spawned)) {      yield* closeScopeDetached(childScope);      return yield* Effect.failCause(spawned.cause);    }     const delegateHandle = spawned.value;    let referenced = true;    const handle = ChildProcessSpawner.makeHandle({      pid: delegateHandle.pid,      exitCode: delegateHandle.exitCode,      isRunning: delegateHandle.isRunning,      kill: (killOptions) => kill(delegateHandle, killOptions),      stdin: delegateHandle.stdin,      stdout: delegateHandle.stdout,      stderr: delegateHandle.stderr,      all: delegateHandle.all,      getInputFd: delegateHandle.getInputFd,      getOutputFd: delegateHandle.getOutputFd,      unref: delegateHandle.unref.pipe(        Effect.tap(() =>          Effect.sync(() => {            referenced = false;          }),        ),        Effect.map((reref) =>          reref.pipe(            Effect.tap(() =>              Effect.sync(() => {                referenced = true;              }),            ),          ),        ),      ),    });    yield* Effect.addFinalizer(() => shutdown(delegateHandle, childScope, () => referenced));    yield* handle.exitCode.pipe(      Effect.exit,      Effect.andThen(Scope.close(childScope, Exit.void)),      Effect.ignoreCause({ log: true }),      Effect.forkDetach({ startImmediately: true }),    );     return handle;  }, Effect.uninterruptible);   return ChildProcessSpawner.make(spawn);}; export const layer = (options?: BoundedChildProcessSpawnerOptions) =>  Layer.effect(    ChildProcessSpawner.ChildProcessSpawner,    Effect.map(ChildProcessSpawner.ChildProcessSpawner, (delegate) => make(delegate, options)),  );