import { spawn } from "node:child_process"; export type DenoPermissions = {  /** Allow network access. Pass `true` for all, or an array of allowed hosts. */  allowNet?: boolean | string[];  /** Allow file read access. Pass `true` for all, or an array of allowed paths. */  allowRead?: boolean | string[];  /** Allow file write access. Pass `true` for all, or an array of allowed paths. */  allowWrite?: boolean | string[];  /** Allow environment variable access. Pass `true` for all, or an array of allowed vars. */  allowEnv?: boolean | string[];  /** Allow running subprocesses. Pass `true` for all, or an array of allowed commands. */  allowRun?: boolean | string[];  /** Allow FFI (foreign function interface). */  allowFfi?: boolean | string[];}; export type SpawnDenoWorkerProcessInput = {  executable: string;  scriptPath: string;  permissions?: DenoPermissions;}; export type DenoWorkerProcessCallbacks = {  onStdoutLine: (line: string) => void;  onStderr: (chunk: string) => void;  onError: (error: Error) => void;  onStdinError: (error: Error) => void;  onExit: (code: number | null, signal: NodeJS.Signals | null) => void;}; export type DenoWorkerProcess = {  ready: Promise<void>;  write: (data: string) => Promise<void>;  dispose: () => void;}; const normalizeError = (cause: unknown): Error =>  cause instanceof Error ? cause : new Error(String(cause)); const buildPermissionArgs = (permissions?: DenoPermissions): string[] => {  if (!permissions) {    return ["--deny-net", "--deny-read", "--deny-write", "--deny-env", "--deny-run", "--deny-ffi"];  }   const args: string[] = [];   const addPermission = (flag: string, value: boolean | string[] | undefined) => {    if (value === true) {      args.push(`--allow-${flag}`);    } else if (Array.isArray(value) && value.length > 0) {      args.push(`--allow-${flag}=${value.join(",")}`);    } else {      args.push(`--deny-${flag}`);    }  };   addPermission("net", permissions.allowNet);  addPermission("read", permissions.allowRead);  addPermission("write", permissions.allowWrite);  addPermission("env", permissions.allowEnv);  addPermission("run", permissions.allowRun);  addPermission("ffi", permissions.allowFfi);   return args;}; export const spawnDenoWorkerProcess = (  input: SpawnDenoWorkerProcessInput,  callbacks: DenoWorkerProcessCallbacks,): DenoWorkerProcess => {  const permissionArgs = buildPermissionArgs(input.permissions);   const child = spawn(    input.executable,    ["run", "--quiet", "--no-prompt", "--no-check", ...permissionArgs, input.scriptPath],    {      stdio: ["pipe", "pipe", "pipe"],    },  );   if (!child.stdin || !child.stdout || !child.stderr) {    throw new Error("Failed to create piped stdio for Deno worker subprocess");  }   const ready = new Promise<void>((resolve, reject) => {    const onSpawn = () => {      child.removeListener("error", onSpawnError);      resolve();    };    const onSpawnError = (cause: unknown) => {      child.removeListener("spawn", onSpawn);      reject(normalizeError(cause));    };     child.once("spawn", onSpawn);    child.once("error", onSpawnError);  });   child.stdout.setEncoding("utf8");  child.stderr.setEncoding("utf8");   let stdoutBuffer = "";   const onStdoutData = (chunk: string) => {    stdoutBuffer += chunk;     while (true) {      const newlineIndex = stdoutBuffer.indexOf("\n");      if (newlineIndex === -1) {        break;      }       const line = stdoutBuffer.slice(0, newlineIndex);      stdoutBuffer = stdoutBuffer.slice(newlineIndex + 1);      callbacks.onStdoutLine(line);    }  };   const onStderrData = (chunk: string) => {    callbacks.onStderr(chunk);  };   const onError = (cause: unknown) => {    callbacks.onError(normalizeError(cause));  };   const onStdinError = (cause: unknown) => {    callbacks.onStdinError(normalizeError(cause));  };   const onStdinClose = () => {    child.stdin.removeListener("error", onStdinError);  };   const onExit = (code: number | null, signal: NodeJS.Signals | null) => {    callbacks.onExit(code, signal);  };   child.stdout.on("data", onStdoutData);  child.stderr.on("data", onStderrData);  child.stdin.on("error", onStdinError);  child.stdin.once("close", onStdinClose);  child.on("error", onError);  child.on("exit", onExit);   let disposed = false;   const write = (data: string): Promise<void> =>    new Promise((resolve, reject) => {      if (disposed || !child.stdin.writable) {        reject(new Error("Deno subprocess stdin is not writable"));        return;      }       child.stdin.write(data, (cause: Error | null | undefined) => {        if (cause) {          reject(cause);          return;        }         resolve();      });    });   const dispose = () => {    if (disposed) {      return;    }     disposed = true;    child.stdout!.removeListener("data", onStdoutData);    child.stderr!.removeListener("data", onStderrData);    child.removeListener("error", onError);    child.removeListener("exit", onExit);    child.stdin.destroy();     if (!child.killed) {      child.kill("SIGKILL");    }  };   return {    ready,    write,    dispose,  };};