@lowlighter/run 3.0.0 → 3.4.1

package/command.mjs

@@ -1 +0,0 @@
-var e=class e{constructor({level:t,format:r,output:n,tags:o,...s}={}){"granted"===globalThis.Deno?.permissions.querySync?.({name:"env",variable:"LOG_LEVEL"}).state&&(t??=globalThis.Deno?.env.get("LOG_LEVEL")),this.#e=n||null===n?n:console,this.#t=e.level.log,this.#r=e.format.text,this.#n={date:!1,time:!1,delta:!0,caller:{file:!1,name:!1,line:!1,fileformat:null}},this.level(t).format(r).options(s),this.tags=o??{}}#e;#n;options(e){if(!e)return structuredClone(this.#n);if("date"in e&&(this.#n.date=e.date),"time"in e&&(this.#n.time=e.time),"delta"in e&&(this.#n.delta=e.delta),"caller"in e)switch(!0){case!0===e.caller:this.#n.caller={file:!0,name:!0,line:!0,fileformat:this.#n.caller.fileformat};break;case!1===e.caller:this.#n.caller={file:!1,name:!1,line:!1,fileformat:this.#n.caller.fileformat};break;case"object"==typeof e.caller:"file"in e.caller&&(this.#n.caller.file=e.caller.file),"name"in e.caller&&(this.#n.caller.name=e.caller.name),"line"in e.caller&&(this.#n.caller.line=e.caller.line),"fileformat"in e.caller&&void 0!==e.caller.fileformat&&(this.#n.caller.fileformat=e.caller.fileformat)}return this}#t;level(t){return arguments.length?(Number.isNaN(Number.parseInt(`${t}`))||(t=Number.parseInt(`${t}`)),"string"==typeof t&&t in e.level&&(t=e.level[t]),"number"==typeof t&&(this.#t=!Number.isNaN(t)&&t>=0?t:-1),this):this.#t>=0?this.#t:NaN}#o=new Map;#s=new Map;censor({values:e=[],keys:t=[],replace:r="[[redacted]]"}){return e.forEach((e=>this.#o.set(e,r))),t.forEach((e=>this.#s.set(e,r))),this}#i(e){return"string"==typeof e?this.#l(e):"object"==typeof e&&e?this.#a(e):e}#l(e){for(const[t,r]of this.#o)e=e.replaceAll(t instanceof RegExp&&!t.flags.includes("g")?new RegExp(t.source,"g"):t,r);return e}#a(e,t={}){for(const[r,n]of Object.entries(e))if(t[r]=n,"object"==typeof n&&n)t[r]=this.#a(n);else if("string"==typeof n){t[r]=this.#l(n);for(const[e,n]of this.#s)r===e&&(t[r]=n),e.test?.(r)&&(t[r]=n)}return t}static level=Object.freeze({disabled:NaN,error:0,warn:1,info:2,ok:2,log:3,debug:4,wdebug:4,trace:5,probe:NaN,always:1/0});error(...t){return this.#t>=e.level.error&&this.#e?.error(...this.#r(this,{level:"error",content:t,options:this.#n})),this}warn(...t){return this.#t>=e.level.warn&&this.#e?.warn(...this.#r(this,{level:"warn",content:t,options:this.#n})),this}info(...t){return this.#t>=e.level.info&&this.#e?.info(...this.#r(this,{level:"info",content:t,options:this.#n})),this}ok(...t){return this.#t>=e.level.info&&this.#e?.info(...this.#r(this,{level:"ok",content:t,options:this.#n})),this}log(...t){return this.#t>=e.level.log&&this.#e?.log(...this.#r(this,{level:"log",content:t,options:this.#n})),this}debug(...t){return this.#t>=e.level.debug&&this.#e?.debug(...this.#r(this,{level:"debug",content:t,options:this.#n})),this}wdebug(...t){return this.#t>=e.level.debug&&this.#e?.debug(...this.#r(this,{level:"wdebug",content:t,options:this.#n})),this}trace(...t){return this.#t>=e.level.trace&&this.#e?.debug(...this.#r(this,{level:"trace",content:t,options:this.#n})),this}probe(...e){return this.#e?.debug(...this.#r(this,{level:"probe",content:e,options:this.#n})),this}tags;with(t={}){const r=new e({level:this.#t,format:this.#r,output:this.#e,...this.#n,tags:{...this.tags,...t}});return this.#o.forEach(((e,t)=>r.#o.set(t,e))),this.#s.forEach(((e,t)=>r.#s.set(t,e))),r}#c(e=3){const t=Error,r=t.prepareStackTrace;t.prepareStackTrace=(e,t)=>t;const{stack:n}=new Error;t.prepareStackTrace=r;return n.map((e=>({file:e.getFileName(),name:e.getFunctionName(),line:e.getLineNumber(),column:e.getColumnNumber()})))[e]}#u(e){return e=this.#i(e),globalThis.Deno?.inspect(e,{colors:!0,depth:1/0,strAbbreviateSize:1/0})??e}#r;format(t){return this.#r=("string"==typeof t?e.format[t]:t)??e.format.text,this}static format={text(e,{level:t,content:r,options:n}){const o={error:"red",warn:"orange",info:"cyan",ok:"green",log:"white",debug:"gray",wdebug:"yellow",trace:"gray",probe:"magenta"}[t],s=[`%c ${t.replace("wdebug","debug").toLocaleUpperCase().padEnd(5)} │%c`],i=[`color: black; background-color: ${o}`,""];if(n.date||n.time||n.delta){const e=(new Date).toISOString(),t=[];if(n.delta){const e=performance.now()/1e3;let r=e.toPrecision(4);e<1&&(r=e.toPrecision(2)),t.push(`+${r}`)}n.date&&n.time?t.push(e):n.date?t.push(e.slice(0,e.indexOf("T"))):n.time&&t.push(e.slice(e.indexOf("T")+1,-1)),s.push(`%c ${t.join(" ¦ ").trim()} %c`),i.push(`color: black; background-color: ${o}`,"")}if(n.caller.file||n.caller.name||n.caller.line){const t=e.#c();if(t){const e=[];if(n.caller.file){let r=`${t.file}`;Array.isArray(n.caller.fileformat)&&(r=r.replace(n.caller.fileformat[0],n.caller.fileformat[1])),e.push(r)}n.caller.name&&t.name&&e.push(t.name),n.caller.line&&e.push(t.line,t.column),s.push(`%c ${e.join(":").trim()} %c`),i.push("color: black; background-color: gray","")}}const l=[];for(const[t,r]of Object.entries(e.tags))l.push(`${t}:${e.#u(r)}`);return s.push(`%c ${l.join(" ").trim()} %c`),i.push("background-color: black",""),[s.join(""),...i,...r.map((t=>e.#u(t)))]},json(e,{level:t,content:r,options:n}){const o={level:t,timestamp:Date.now(),tags:Object.fromEntries(Object.entries(e.tags).map((([t,r])=>[t,e.#i(r)]))),content:r.map((t=>e.#i(t)))},s={};if(n.date||n.time){const e=new Date(o.timestamp).toISOString();n.date&&(s.date=e.slice(0,e.indexOf("T"))),n.time&&(s.time=e.slice(e.indexOf("T")+1,-1))}if(n.delta&&(s.delta=performance.now()/1e3),n.caller.file||n.caller.name||n.caller.line){const t=e.#c();if(t){if(s.caller={},n.caller.file){let e=`${t.file}`;Array.isArray(n.caller.fileformat)&&(e=e.replace(n.caller.fileformat[0],n.caller.fileformat[1])),s.caller.file=e}n.caller.name&&t.name&&(s.caller.name=t.name),n.caller.line&&(s.caller.line=[t.line,t.column])}}return[JSON.stringify({...o,...s})]}}};TransformStream;function t(e){let t=0;for(const r of e)t+=r.length;const r=new Uint8Array(t);let n=0;for(const t of e)r.set(t,n),n+=t.length;return r}function r(e){const t=e.length,r=new Uint8Array(t);r[0]=0;let n=0,o=1;for(;o<t;)e[o]===e[n]?(n++,r[o]=n,o++):0===n?(r[o]=0,o++):n=r[n-1];return r}TransformStream,TransformStream,TransformStream,TransformStream;var n=class extends TransformStream{#d="";constructor(e={allowCR:!1}){super({transform:(t,r)=>{for(t=this.#d+t;;){const n=t.indexOf("\n"),o=e.allowCR?t.indexOf("\r"):-1;if(-1!==o&&o!==t.length-1&&(-1===n||n-1>o)){r.enqueue(t.slice(0,o)),t=t.slice(o+1);continue}if(-1===n)break;const s="\r"===t[n-1]?n-1:n;r.enqueue(t.slice(0,s)),t=t.slice(n+1)}this.#d=t},flush:t=>{if(""===this.#d)return;const r=e.allowCR&&this.#d.endsWith("\r")?this.#d.slice(0,-1):this.#d;t.enqueue(r)}})}};var o=new TextEncoder,s=new TextDecoder;function i(t,r,{logger:i=new e,stdin:a=null,stdout:c="debug",stderr:u="error",env:d,cwd:h,raw:f,callback:p,buffering:m,sync:g,throw:w,dryrun:b,winext:v="",os:y=Deno.build.os}={}){"windows"===y&&(t=`${t}${v}`),i=i.with({bin:t}),p&&"piped"!==l(a)&&(a="piped");const k=new Deno.Command(t,{args:r,stdin:g?"null":l(a),stdout:l(c),stderr:l(u),env:d,cwd:h,windowsRawArguments:f});if(b){i.wdebug(`dryrun: ${t} not executed`);const e={success:!0,code:0,stdio:[],stdin:"",stdout:"",stderr:""};return g?e:Promise.resolve(e)}return g?function(e,{bin:t,log:r,throw:n,stdout:o,stderr:i}){const a=Date.now(),c=e.outputSync(),{success:u,code:d}=c,h=Date.now()-a,f={get stdio(){return[[h,1,this.stdout],[h,2,this.stderr]]},stdin:"",stdout:"piped"===l(o)?s.decode(c.stdout):"",stderr:"piped"===l(i)?s.decode(c.stderr):""};for(const{channel:e,mode:t}of[{channel:"stdout",mode:o},{channel:"stderr",mode:i}])"piped"===l(t)&&f[e]&&r.with({t:h,channel:e})[t]?.(f[e]);if(!u&&n)throw new EvalError(`${t} exited with non-zero code ${d}:\n${f.stdout}\n${f.stderr}`);return{success:u,code:d,...f}}(k,{bin:t,log:i,throw:w,stdout:c,stderr:u}):async function(e,{bin:t,log:r,callback:s=({close:e})=>e?.(),buffering:i=250,throw:a,...c}){const u=e.spawn(),d=Date.now(),h={stdio:[],get stdin(){return this.stdio.filter((([e,t])=>0===t)).map((([e,t,r])=>r)).join("\n")},get stdout(){return this.stdio.filter((([e,t])=>1===t)).map((([e,t,r])=>r)).join("\n")},get stderr(){return this.stdio.filter((([e,t])=>2===t)).map((([e,t,r])=>r)).join("\n")}},f={};let p="";const m=function(e,t){let r=null,n=null;const o=(...s)=>{o.clear(),n=()=>{o.clear(),e.call(o,...s)},r=Number(setTimeout(n,t))};return o.clear=()=>{"number"==typeof r&&(clearTimeout(r),r=null,n=null)},o.flush=()=>{n?.()},Object.defineProperty(o,"pending",{get:()=>"number"==typeof r}),o}((async e=>{r.with({t:e}).trace("debounced"),p="",await s({stdio:h,i:h.stdin.length,...f})}),i);if("piped"===l(c.stdin)){const e=u.stdin.getWriter();Object.assign(f,{async write(t,n=!0){const s=Date.now()-d;c.stdin&&r.with({t:s,channel:"stdin"})[c.stdin]?.(t),h.stdio.push([s,0,t]),n&&!t.endsWith("\n")&&(t+="\n"),await e.write(o.encode(t)),p="stdin",e.releaseLock()},async close(){try{e.releaseLock(),await u.stdin.close(),r.with({t:Date.now()-d,closed:"stdin"}).trace()}catch{}},async wait(e=1e3){const t=Date.now()-d;r.with({t:t,waiting:e}).trace(),await function(e,t={}){const{signal:r,persistent:n=!0}=t;return r?.aborted?Promise.reject(r.reason):new Promise(((t,o)=>{const s=()=>{clearTimeout(i),o(r?.reason)},i=setTimeout((()=>{r?.removeEventListener("abort",s),t()}),e);if(r?.addEventListener("abort",s,{once:!0}),!1===n)try{Deno.unrefTimer(i)}catch(e){if(!(e instanceof ReferenceError))throw e;console.error("`persistent` option is only available in Deno")}}))}(e),m(t)}}),m(Date.now()-d)}await Promise.all(["stdout","stderr"].filter((e=>"piped"===l(c[e]))).map((async e=>{for await(const t of u[e].pipeThrough(new TextDecoderStream).pipeThrough(new n)){const n=Date.now()-d,o={stdout:1,stderr:2}[e];if(c[e]&&r.with({t:n,channel:e})[c[e]]?.(t),h.stdio.length&&p===e){const e=h.stdio.at(-1);e[1]===o&&(e[2]+=`\n${t}`)}else h.stdio.push([n,o,t]);p=e,m(n)}}))),m.flush();const{success:g,code:w}=await u.status;if(!g&&a)throw new EvalError(`${t} exited with non-zero code ${w}:\n${h.stdout}\n${h.stderr}`);return{success:g,code:w,...h}}(k,{bin:t,log:i,callback:p,buffering:m,throw:w,stdin:"piped"===l(a)?a:null,stdout:"piped"===l(c)?c:null,stderr:"piped"===l(u)?u:null})}function l(e){return["inherit","null"].includes(`${e}`)?`${e}`:"piped"}export{i as command};

package/command.ts

@@ -1,324 +0,0 @@
-// Imports
-import type { Arg, Nullable, Promisable } from "@libs/typing"
-import { Logger, type loglevel } from "@libs/logger"
-import { TextLineStream } from "@std/streams"
-import { debounce } from "@std/async/debounce"
-import { delay } from "@std/async/delay"
-export type { Logger, loglevel, Promisable }
-
-/** Run options. */
-export type options = {
-  /** Logger instance. */
-  logger?: Logger
-  /** Environment variables. */
-  env?: Deno.CommandOptions["env"]
-  /** Current working directory. */
-  cwd?: Deno.CommandOptions["cwd"]
-  /** Raw arguments (Windows only). */
-  raw?: boolean
-  /** Handling of stdin. When using a loglevel, channel will be piped and logged to specified log level. */
-  stdin?: loglevel | "piped" | "inherit" | null
-  /** Handling of stdout. When using a loglevel, channel will be piped and logged to specified log level. */
-  stdout?: loglevel | "piped" | "inherit" | null
-  /** Handling of stderr. When using a loglevel, channel will be piped and logged to specified log level. */
-  stderr?: loglevel | "piped" | "inherit" | null
-  /**
-   * Stdin interaction callback.
-   * Each time data is received on either stdin or stdout, this will be called after input buffering.
-   * You can then read stdio content, write to stdin, close stdin or retry later (for polling).
-   * Passing this option will automatically set stdin to "piped" if it is "inherit" or "null".
-   */
-  callback?: callback
-  /**
-   * Stdio buffering.
-   * This is used to merge messages that are received relatively closely.
-   * Buffering is skipped when a different channel is used in-between.
-   */
-  buffering?: number
-  /**
-   * Execute process synchronously.
-   * Note that stdin is not usable in sync mode.
-   */
-  sync?: boolean
-  /** Process extension on Windows. */
-  winext?: string
-  /** Operating system. */
-  os?: typeof Deno.build.os
-  /** Throw an error if exit code is non-zero rather than returning a result. */
-  throw?: boolean
-  /**
-   * Do not actually execute the command.
-   * In this case you will instead receive an empty successful result object.
-   */
-  dryrun?: boolean
-}
-
-/** Run result. */
-export type result = {
-  /** Whether the process exited with a zero-code. */
-  success: Deno.CommandStatus["success"]
-  /** Process exit code. */
-  code: Deno.CommandStatus["code"]
-  /**
-   * Process stdio content.
-   * First element is the delta timestamp since process start, second element is the channel (0:stdin, 1:stdout, 2:stderr), third element is the content.
-   */
-  stdio: Array<[number, 0 | 1 | 2, string]>
-  /** Process stdin content. */
-  stdin: string
-  /** Process stdout content. */
-  stdout: string
-  /** Process stderr content. */
-  stderr: string
-}
-
-/** Stdin interaction callback. */
-export type callback = (options: { stdio: Pick<result, "stdin" | "stdout" | "stderr">; i: number; write: (content: string) => Promise<void>; close: () => Promise<void>; wait: (dt: number) => Promise<void> }) => Promisable<void>
-
-/** Text encoder */
-const encoder = new TextEncoder()
-
-/** Text decoder */
-const decoder = new TextDecoder()
-
-/**
- * Asynchronous version of {@link command}.
- *
- * Note that stdin is not usable in sync mode and will always be empty.
- *
- * @example
- * ```ts
- * import { command } from "./command.ts"
- * command("deno", ["version"], { sync: true })
- * ```
- * @example
- * ```
- * import { command } from "./command.ts"
- * try {
- *   command("deno", ["eval", "Deno.exit(1)"], { sync: true, throw: true })
- * }
- * catch (error) {
- *   console.log(error)
- * }
- * ```
- */
-export function command(bin: string, args: string[], options?: options & { sync?: false }): Promise<result>
-/**
- * Synchronous version of {@link command}.
- *
- * @example
- * ```
- * import { command } from "./command.ts"
- * try {
- *   await command("deno", ["eval", "Deno.exit(1)"], { throw: true })
- * }
- * catch (error) {
- *   console.log(error)
- * }
- * ```
- */
-export function command(bin: string, args: string[], options?: options & { sync: true }): result
-/**
- * Run a command.
- *
- * This is a wrapper around {@link https://docs.deno.com/api/deno/~/Deno.Command | Deno.command} that provides a better handling of stdio for interactive processes.
- *
- * Like `Deno.command`, the `env`, `cwd`, and `raw` (alias for `windowsRawArguments`) options are supported.
- *
- * The `stdin`, `stdout` and `stderr` options can be either set to an allowed {@link https://docs.deno.com/api/deno/~/Deno.Command | Deno.command} values (`"inherit"`, `"null"`, `"piped"`), or either to a supported log level of {@link Logger}.
- * In the later case, the content will be always be "piped" and logged to the specified level of the provided {@link Logger} instance.
- *
- * Set `winext` option to automatically append an extension to the binary path on Windows (like `.cmd` or `.exe`).
- * This is useful when the binary path isn't automatically resolved on Windows.
- *
- * Pass a `callback` option to interact with the process stdin and stdout.
- * It is called each time data is received on of the piped channels, after input buffering.
- * It will receive an object with the current stdio content, the current command index (based on the content written to stdin), along with a few additional functions:
- * - `write(content: string, newline?: boolean): Promise<void>` encodes and writes content to stdin.
- *   - A newline is automatically appended by default but can be toggled off by passing `false` as second argument.
- * - `close(): Promise<void>` closes stdin.
- *   - Note that you **need** to eventually call this method to prevent most processes from hanging as they're waiting for more input.
- * - `wait(dt: number): Promise<void>` waits for a given amount of time before calling the callback again.
- *   - It is especially useful for polling, like checking if a specific line has been written to stdio or not.
- *
- * The `buffering` option is used to merge messages that are received relatively closely.
- * Setting this option to a low value will also increase the rate at which the `callback` is called.
- *
- * Resulting object contains the same properties as {@link https://docs.deno.com/api/deno/~/Deno.CommandStatus | Deno.CommandStatus}
- * with an additional `stdio` property that contains an array of ordered tuples with the delta timestamp since process start, the channel idenfitier (0:stdin, 1:stdout, 2:stderr) and the content.
- * This offers a proper history of exchanged content.
- *
- * @example
- * ```ts
- * import { command } from "./command.ts"
- * import { Logger } from "jsr:@libs/logger"
- * await command("deno", ["version"], { env: { NO_COLOR: "true" }, cwd: "/tmp", raw: true })
- * await command("deno", ["version"], { stdout: "piped" })
- * await command("deno", ["version"], { logger: new Logger(), stdout: "debug" })
- * await command("deno", ["version"], { winext: ".exe" })
- * ```
- *
- * @example
- * ```ts
- * import { command } from "./command.ts"
- *
- * const { stdout } = await command("deno", ["repl"], {
- *   env: { NO_COLOR: "true" },
- *   // Passing a callback will automatically set `stdin` to `"piped"`
- *   // You can then write to the process using utility functions
- *   callback: async ({ i, stdio, write, close, wait }) => {
- *     if ((!stdio.stdout.includes("exit using")) || (i))
- *       return
- *     await write("console.log('hello')")
- *     await wait(1000)
- *     close()
- *   },
- * })
- * console.assert(stdout.includes("hello"))
- * ```
- *
- * @author Simon Lecoq (lowlighter)
- * @license MIT
- * @module
- */
-export function command(bin: string, args: string[], { logger: log = new Logger(), stdin = null, stdout = "debug", stderr = "error", env, cwd, raw, callback, buffering, sync, throw: _throw, dryrun, winext = "", os = Deno.build.os } = {} as options): Promisable<result> {
-  if (os === "windows") {
-    bin = `${bin}${winext}`
-  }
-  log = log.with({ bin })
-  if (callback && (handle(stdin) !== "piped")) {
-    stdin = "piped"
-  }
-  const command = new Deno.Command(bin, { args, stdin: !sync ? handle(stdin) : "null", stdout: handle(stdout), stderr: handle(stderr), env, cwd, windowsRawArguments: raw })
-  if (dryrun) {
-    log.wdebug(`dryrun: ${bin} not executed`)
-    const result = { success: true, code: 0, stdio: [], stdin: "", stdout: "", stderr: "" }
-    return sync ? result : Promise.resolve(result)
-  }
-  if (sync) {
-    return exec(command, { bin, log, throw: _throw, stdout, stderr })
-  }
-  return spawn(command, { bin, log, callback, buffering, throw: _throw, stdin: handle(stdin) === "piped" ? stdin as loglevel : null, stdout: handle(stdout) === "piped" ? stdout as loglevel : null, stderr: handle(stderr) === "piped" ? stderr as loglevel : null })
-}
-
-/** Returns the handle type for a given mode. */
-function handle(mode: Nullable<string>) {
-  return ["inherit", "null"].includes(`${mode}`) ? `${mode}` as "inherit" | "null" : "piped"
-}
-
-/** Execute a command synchronously. */
-function exec(command: Deno.Command, { bin, log, throw: _throw, stdout, stderr }: { bin: string; log: Logger; throw?: boolean; stdout: Nullable<string>; stderr: Nullable<string> }) {
-  const start = Date.now()
-  const output = command.outputSync()
-  const { success, code } = output // Do not access stdout or stderr before "piped" status check
-  const t = Date.now() - start
-  const stdio = {
-    get stdio() {
-      return [[t, 1, this.stdout], [t, 2, this.stderr]]
-    },
-    stdin: "",
-    stdout: handle(stdout) === "piped" ? decoder.decode(output.stdout) : "",
-    stderr: handle(stderr) === "piped" ? decoder.decode(output.stderr) : "",
-  } as Pick<result, "stdio" | "stdin" | "stdout" | "stderr">
-  for (const { channel, mode } of [{ channel: "stdout", mode: stdout }, { channel: "stderr", mode: stderr }] as const) {
-    if ((handle(mode) === "piped") && (stdio[channel])) {
-      log.with({ t, channel })[mode as loglevel]?.(stdio[channel])
-    }
-  }
-  if ((!success) && _throw) {
-    throw new EvalError(`${bin} exited with non-zero code ${code}:\n${stdio.stdout}\n${stdio.stderr}`)
-  }
-  return { success, code, ...stdio }
-}
-
-/** Spawn a command asynchronously. */
-async function spawn(
-  command: Deno.Command,
-  { bin, log, callback = ({ close }) => close?.(), buffering = 250, throw: _throw, ...channels }: { bin: string; log: Logger; callback?: callback; buffering?: number; throw?: boolean; stdin: Nullable<loglevel>; stdout: Nullable<loglevel>; stderr: Nullable<loglevel> },
-) {
-  const process = command.spawn()
-  const start = Date.now()
-  const stdio = {
-    stdio: [],
-    get stdin() {
-      return this.stdio.filter(([_, i]) => i === 0).map(([_, __, content]) => content).join("\n")
-    },
-    get stdout() {
-      return this.stdio.filter(([_, i]) => i === 1).map(([_, __, content]) => content).join("\n")
-    },
-    get stderr() {
-      return this.stdio.filter(([_, i]) => i === 2).map(([_, __, content]) => content).join("\n")
-    },
-  } as Pick<result, "stdio" | "stdin" | "stdout" | "stderr">
-  const options = {} as Pick<Arg<callback>, "write" | "close" | "wait">
-  let last = ""
-  const debounced = debounce(async (t: number) => {
-    log.with({ t }).trace("debounced")
-    last = ""
-    await callback({ stdio, i: stdio.stdin.length, ...options })
-  }, buffering)
-  // Prepare stdin handlers if channel is piped
-  if (handle(channels.stdin) === "piped") {
-    const writer = process.stdin.getWriter()
-    Object.assign(options, {
-      async write(content: string, newline = true) {
-        const t = Date.now() - start
-        if (channels.stdin) {
-          log.with({ t, channel: "stdin" })[channels.stdin]?.(content)
-        }
-        stdio.stdio.push([t, 0, content])
-        if (newline && (!content.endsWith("\n"))) {
-          content += "\n"
-        }
-        await writer.write(encoder.encode(content))
-        last = "stdin"
-        writer.releaseLock()
-      },
-      async close() {
-        try {
-          writer.releaseLock()
-          await process.stdin.close()
-          log.with({ t: Date.now() - start, closed: "stdin" }).trace()
-        } catch {
-          // Ignore
-        }
-      },
-      async wait(dt = 1000) {
-        const t = Date.now() - start
-        log.with({ t, waiting: dt }).trace()
-        await delay(dt)
-        debounced(t)
-      },
-    })
-    debounced(Date.now() - start)
-  }
-  // Buffer output and debounce interaction callback
-  await Promise.all(
-    (["stdout", "stderr"] as const).filter((channel) => handle(channels[channel]) === "piped").map(async (channel) => {
-      for await (const line of process[channel].pipeThrough(new TextDecoderStream()).pipeThrough(new TextLineStream())) {
-        const t = Date.now() - start
-        const stdi = { stdout: 1, stderr: 2 }[channel] as 1 | 2
-        if (channels[channel]) {
-          log.with({ t, channel })[channels[channel]!]?.(line)
-        }
-        if ((stdio.stdio.length) && (last === channel)) {
-          const previous = stdio.stdio.at(-1)!
-          if (previous[1] === stdi) {
-            previous[2] += `\n${line}`
-          }
-        } else {
-          stdio.stdio.push([t, stdi, line])
-        }
-        last = channel
-        debounced(t)
-      }
-    }),
-  )
-  debounced.flush()
-  // Result
-  const { success, code } = await process.status
-  if ((!success) && _throw) {
-    throw new EvalError(`${bin} exited with non-zero code ${code}:\n${stdio.stdout}\n${stdio.stderr}`)
-  }
-  return { success, code, ...stdio }
-}

package/command_test.ts

@@ -1,127 +0,0 @@
-import { Logger } from "@libs/logger"
-import { command } from "./command.ts"
-import { expect, test, type testing } from "@libs/testing"
-
-test("deno")("`command()` can spawn subprocesses asynchronously", async () => {
-  let result = command("deno", ["--version"], { env: { NO_COLOR: "true" } }) as testing
-  expect(result).toBeInstanceOf(Promise)
-  result = await result
-  expect(result).toMatchObject({ success: true, code: 0, stdin: "", stderr: "" })
-  expect(result.stdio).toBeInstanceOf(Array)
-  expect(result.stdout).toMatch(/deno/)
-}, { permissions: { run: ["deno"] } })
-
-test("deno")("`command()` can spawn subprocesses synchronously", () => {
-  const result = command("deno", ["--version"], { env: { NO_COLOR: "true" }, sync: true })
-  expect(result).not.toBeInstanceOf(Promise)
-  expect(result).toMatchObject({ success: true, code: 0, stdin: "", stderr: "" })
-  expect(result.stdio).toBeInstanceOf(Array)
-  expect(result.stdout).toMatch(/deno/)
-}, { permissions: { run: ["deno"] } })
-
-test("deno")("`command()` handles `callback<write()>` and `callback<close()>` calls", async () => {
-  const result = await command("deno", ["repl"], { stdin: "debug", env: { NO_COLOR: "true" }, callback: ({ i, write, close }) => i === 0 ? write("console.log('hello')") : close() })
-  expect(result).toMatchObject({ success: true, code: 0, stdin: "console.log('hello')" })
-  expect(result.stdout).toMatch(/hello/)
-}, { permissions: { run: ["deno"] } })
-
-test("deno")("`command()` handles multiple `callback<close()>` calls", async () => {
-  const result = await command("deno", ["repl"], {
-    env: { NO_COLOR: "true" },
-    callback: async ({ close }) => {
-      await close()
-      await close()
-    },
-  })
-  expect(result).toMatchObject({ success: true, code: 0 })
-}, { permissions: { run: ["deno"] } })
-
-test("deno")("`command()` handles `callback<wait()>` calls", async () => {
-  let waited = false
-  const result = await command("deno", ["repl"], {
-    env: { NO_COLOR: "true" },
-    callback: ({ wait, close }) => waited ? close() : (waited = true, wait(250)),
-  })
-  expect(result).toMatchObject({ success: true, code: 0 })
-}, { permissions: { run: ["deno"] } })
-
-for (const sync of [false, true]) {
-  for (const mode of ["inherit", "piped", null, "debug", "log", "info", "warn", "error"] as const) {
-    test("deno")(`\`command()\` supports stdio set to \`"${mode}"\` in ${sync ? "sync" : "async"} mode`, async () => {
-      const result = await command("deno", ["eval", "null"], {
-        logger: new Logger({ level: "disabled" }),
-        env: { NO_COLOR: "true" },
-        stdin: mode,
-        stdout: mode,
-        stderr: mode,
-        sync: sync as testing,
-      })
-      expect(result).toMatchObject({ success: true, code: 0 })
-    }, { permissions: { run: ["deno"] } })
-  }
-}
-
-test("deno")("`command()` handles both stdout and stderr channels", async () => {
-  const result = await command("deno", ["eval", "await Deno.stdout.write(new TextEncoder().encode(`foo\n`));await Deno.stderr.write(new TextEncoder().encode(`bar\n`))"], {
-    env: { NO_COLOR: "true" },
-    stdout: "piped",
-    stderr: "piped",
-  })
-  expect(result).toMatchObject({ success: true, code: 0, stdout: "foo", stderr: "bar" })
-}, { permissions: { run: ["deno"] } })
-
-test("deno")("`command()` supports buffering", async () => {
-  // Combined entries if buffering is greater than the time between writes
-  {
-    const result = await command("deno", ["eval", "console.log(`foo`);await new Promise(resolve => setTimeout(resolve, 100));console.log(`bar`)"], {
-      env: { NO_COLOR: "true" },
-      buffering: 150,
-    })
-    expect(result.stdio).toHaveLength(1)
-    expect(result.stdio[0][2]).toBe("foo\nbar")
-    expect(result.stdout).toBe("foo\nbar")
-  }
-  // Separated entries if buffering is less than the time between writes
-  {
-    const result = await command("deno", ["eval", "console.log(`foo`);await new Promise(resolve => setTimeout(resolve, 100));console.log(`bar`)"], {
-      env: { NO_COLOR: "true" },
-      buffering: 50,
-    })
-    expect(result.stdio).toHaveLength(2)
-    expect(result.stdio[0][2]).toBe("foo")
-    expect(result.stdio[1][2]).toBe("bar")
-    expect(result.stdout).toBe("foo\nbar")
-  }
-  // Separated entries even if buffering is active but channel was changed in-between
-  {
-    const result = await command("deno", [
-      "eval",
-      "await Deno.stdout.write(new TextEncoder().encode(`foo\n`));await Deno.stderr.write(new TextEncoder().encode(`baz\n`));await Deno.stdout.write(new TextEncoder().encode(`bar\n`))",
-    ], {
-      stdout: "piped",
-      stderr: "piped",
-      env: { NO_COLOR: "true" },
-      buffering: 200,
-    })
-    expect(result.stdio).toHaveLength(3)
-    expect(result.stdio[0][2]).toBe("foo")
-    expect(result.stdio[1][2]).toBe("baz")
-    expect(result.stdio[2][2]).toBe("bar")
-    expect(result.stdout).toBe("foo\nbar")
-    expect(result.stderr).toBe("baz")
-  }
-}, { permissions: { run: ["deno"] } })
-
-test("deno")("`command()` throws an error when throw option is enabled and exit code is non-zero", async () => {
-  expect(() => command("deno", ["eval", "Deno.exit(1)"], { env: { NO_COLOR: "true" }, throw: true, sync: true })).toThrow(EvalError)
-  await expect(command("deno", ["eval", "Deno.exit(1)"], { env: { NO_COLOR: "true" }, throw: true })).rejects.toThrow(EvalError)
-}, { permissions: { run: ["deno"] } })
-
-test("deno")("`command()` does nothing in dryrun", async () => {
-  expect(command("deno", ["--version"], { dryrun: true, sync: true })).toMatchObject({ success: true, code: 0, stdio: [], stdin: "", stderr: "", stdout: "" })
-  await expect(command("deno", ["--version"], { dryrun: true })).resolves.toMatchObject({ success: true, code: 0, stdio: [], stdin: "", stderr: "", stdout: "" })
-}, { permissions: { run: ["deno"] } })
-
-test("deno")("`command()` appends windows extension when os platform is windows", () => {
-  expect(command("", ["--version"], { logger: new Logger({ level: "disabled" }), sync: true, winext: "deno", os: "windows" })).toMatchObject({ success: true, code: 0 })
-}, { permissions: { run: ["deno"] } })

package/deno.jsonc

@@ -1,82 +0,0 @@
-{
-  "icon": "⏯️",
-  "name": "@libs/run",
-  "version": "3.0.0",
-  "description": "Utilities to run subprocess.",
-  "keywords": [
-    "subprocess",
-    "esm"
-  ],
-  "license": "MIT",
-  "author": "lowlighter (Simon Lecoq)",
-  "funding": "https://github.com/sponsors/lowlighter",
-  "homepage": "https://github.com/lowlighter/libs",
-  "playground": "https://libs.lecoq.io/run",
-  "supported": [
-    "deno"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/lowlighter/libs.git"
-  },
-  "npm": true,
-  "exports": {
-    ".": "./mod.ts",
-    "./command": "./command.ts"
-  },
-  "imports": {
-    "@std/async/delay": "jsr:@std/async@1/delay",
-    "@std/async/debounce": "jsr:@std/async@1/debounce",
-    "@std/streams": "jsr:@std/streams@1",
-    "@libs/logger": "jsr:@libs/logger@3",
-    "@libs/testing": "jsr:@libs/testing@3",
-    "@libs/typing": "jsr:@libs/typing@3"
-  },
-  "test:permissions": {
-    "run": [
-      "deno",
-      "node",
-      "bun",
-      "npx"
-    ]
-  },
-  "tasks": {
-    "test": "deno test --allow-run=deno,node,bun,npx --no-prompt --coverage --clean --trace-leaks --doc",
-    "dev": "deno fmt && deno task test --filter='/DENO/' && deno coverage --exclude=.js --detailed && deno task lint",
-    "test:deno": "deno task clean:deno && deno fmt --check && deno task test --filter='/DENO/' --quiet && deno coverage --exclude=.js && deno lint",
-    "test:deno-future": "deno task clean:deno && DENO_FUTURE=1 && deno task test:deno",
-    "test:others": "deno task clean:others && deno fmt --check && deno task test --filter='/NODE|BUN/' --quiet && deno coverage --exclude=.js && deno lint",
-    "coverage:html": "deno task test --filter='/DENO/' --quiet && deno coverage --exclude=.js --html && sleep 1",
-    "lint": "deno fmt --check && deno lint && deno doc --lint mod.ts && deno publish --dry-run --quiet --allow-dirty",
-    "clean:deno": "rm -rf node_modules .npmrc deno.lock",
-    "clean:others": "rm -rf node_modules .npmrc deno.lock package.json package-lock.json bun.lockb"
-  },
-  "lint": {
-    "rules": {
-      "include": [
-        "no-throw-literal",
-        "no-eval",
-        "eqeqeq",
-        "ban-untagged-todo"
-      ]
-    },
-    "exclude": [
-      "**/wasm_*",
-      "**/*.mjs"
-    ]
-  },
-  "fmt": {
-    "lineWidth": 280,
-    "semiColons": false,
-    "exclude": [
-      "coverage",
-      "**/coverage",
-      "**/node_modules",
-      "**/package.json",
-      "**/package-lock.json",
-      "**/wasm_*",
-      "**/*.mjs"
-    ],
-    "proseWrap": "preserve"
-  }
-}

package/deno.lock

@@ -1,95 +0,0 @@
-{
-  "version": "4",
-  "specifiers": {
-    "jsr:@libs/logger@*": "3.0.0",
-    "jsr:@libs/logger@3": "3.0.0",
-    "jsr:@libs/testing@3": "3.0.0",
-    "jsr:@libs/typing@2": "2.9.0",
-    "jsr:@libs/typing@3": "3.0.0",
-    "jsr:@std/assert@1": "1.0.6",
-    "jsr:@std/assert@^1.0.6": "1.0.6",
-    "jsr:@std/async@1": "1.0.5",
-    "jsr:@std/bytes@^1.0.2": "1.0.2",
-    "jsr:@std/expect@1": "1.0.4",
-    "jsr:@std/fmt@1": "1.0.2",
-    "jsr:@std/html@1": "1.0.3",
-    "jsr:@std/http@1": "1.0.7",
-    "jsr:@std/internal@^1.0.4": "1.0.4",
-    "jsr:@std/streams@1": "1.0.6",
-    "npm:highlight.js@11": "11.10.0"
-  },
-  "jsr": {
-    "@libs/logger@3.0.0": {
-      "integrity": "c3372ddc9f057ab39248ba51c404984be779fe9d5d9a54ef548714fc2d5512ff"
-    },
-    "@libs/testing@3.0.0": {
-      "integrity": "514547988fadac36890692ccafc932546d9e27680df1b736dd7674ad2e7c9625",
-      "dependencies": [
-        "jsr:@libs/typing@2",
-        "jsr:@std/assert@1",
-        "jsr:@std/expect",
-        "jsr:@std/fmt",
-        "jsr:@std/html",
-        "jsr:@std/http",
-        "npm:highlight.js"
-      ]
-    },
-    "@libs/typing@2.9.0": {
-      "integrity": "ddf35ea652b807cd9b19b4f3f163fb5d76d57299053753fbd01ba8b02d9306ad"
-    },
-    "@libs/typing@3.0.0": {
-      "integrity": "f84ffbbdcbb6a02e6a527911b1399dc79f6ad213aec4ad0a86c95df4b353738f"
-    },
-    "@std/assert@1.0.6": {
-      "integrity": "1904c05806a25d94fe791d6d883b685c9e2dcd60e4f9fc30f4fc5cf010c72207",
-      "dependencies": [
-        "jsr:@std/internal"
-      ]
-    },
-    "@std/async@1.0.5": {
-      "integrity": "31d68214bfbb31bd4c6022401d484e3964147c76c9220098baa703a39b6c2da6"
-    },
-    "@std/bytes@1.0.2": {
-      "integrity": "fbdee322bbd8c599a6af186a1603b3355e59a5fb1baa139f8f4c3c9a1b3e3d57"
-    },
-    "@std/expect@1.0.4": {
-      "integrity": "97f68a445a9de0d9670200d2b7a19a7505a01b2cb390a983ba8d97d90ce30c4f",
-      "dependencies": [
-        "jsr:@std/assert@^1.0.6",
-        "jsr:@std/internal"
-      ]
-    },
-    "@std/fmt@1.0.2": {
-      "integrity": "87e9dfcdd3ca7c066e0c3c657c1f987c82888eb8103a3a3baa62684ffeb0f7a7"
-    },
-    "@std/html@1.0.3": {
-      "integrity": "7a0ac35e050431fb49d44e61c8b8aac1ebd55937e0dc9ec6409aa4bab39a7988"
-    },
-    "@std/http@1.0.7": {
-      "integrity": "9b904fc256678a5c9759f1a53a24a3fdcc59d83dc62099bb472683b6f819194c"
-    },
-    "@std/internal@1.0.4": {
-      "integrity": "62e8e4911527e5e4f307741a795c0b0a9e6958d0b3790716ae71ce085f755422"
-    },
-    "@std/streams@1.0.6": {
-      "integrity": "022ed94e380d06b4d91c49eb70241b7289ab78b8c2b4c4bbb7eb265e4997c25c",
-      "dependencies": [
-        "jsr:@std/bytes"
-      ]
-    }
-  },
-  "npm": {
-    "highlight.js@11.10.0": {
-      "integrity": "sha512-SYVnVFswQER+zu1laSya563s+F8VDGt7o35d4utbamowvUNLLMovFqwCLSocpZTz3MgaSRA1IbqRWZv97dtErQ=="
-    }
-  },
-  "workspace": {
-    "dependencies": [
-      "jsr:@libs/logger@3",
-      "jsr:@libs/testing@3",
-      "jsr:@libs/typing@3",
-      "jsr:@std/async@1",
-      "jsr:@std/streams@1"
-    ]
-  }
-}