@poe-platform/safe-bash 0.1.755 → 0.1.757

package/dist/safe-bash/chunks/chunk-LB6HVRXS.js

@@ -1,857 +0,0 @@
-import {
-  value_exports
-} from "./chunk-CGL53DQQ.js";
-import {
-  command_exports,
-  io_exports
-} from "./chunk-G2VCIF2J.js";
-import {
-  init_platform
-} from "./chunk-ZG7GWQ5P.js";
-
-// packages/safe-bash-command-timeout/src/signal.ts
-init_platform();
-var signalNames = ["HUP", "INT", "QUIT", "ILL", "TRAP", "ABRT", "BUS", "FPE", "KILL", "USR1", "SEGV", "USR2", "PIPE", "ALRM", "TERM", "STKFLT", "CHLD", "CONT", "STOP", "TSTP", "TTIN", "TTOU", "URG", "XCPU", "XFSZ", "VTALRM", "PROF", "WINCH", "IO", "PWR", "SYS"];
-function signalName(number) {
-  return signalNames[number - 1] ?? String(number);
-}
-function parseSignal(value) {
-  let name = value.toUpperCase();
-  if (name.startsWith("SIG")) name = name.slice(3);
-  if (name === "EXIT") return 0;
-  if (name.length > 0 && [...name].every((character) => character >= "0" && character <= "9")) {
-    const number = Number(name);
-    return number <= 64 ? number : void 0;
-  }
-  if (name === "IOT") name = "ABRT";
-  if (name === "CLD") name = "CHLD";
-  if (name === "POLL") name = "IO";
-  const index = signalNames.indexOf(name);
-  if (index >= 0) return index + 1;
-  for (const [prefix, base, direction] of [["RTMIN", 34, 1], ["RTMAX", 64, -1]]) {
-    if (name === prefix) return base;
-    const separator = direction === 1 ? "+" : "-";
-    if (name.startsWith(prefix + separator)) {
-      const offset = name.slice(prefix.length + 1);
-      if (offset.length > 0 && [...offset].every((character) => character >= "0" && character <= "9")) {
-        const number = base + direction * Number(offset);
-        if (number >= 34 && number <= 64) return number;
-      }
-    }
-  }
-  return void 0;
-}
-
-// packages/safe-bash/src/shell/extensions/jobs/index.ts
-init_platform();
-
-// packages/safe-bash/src/shell/extensions/jobs/state.ts
-init_platform();
-var JobRegistry = class {
-  constructor(limits, options) {
-    this.limits = limits;
-    this.#owner = options.signal;
-    this.#abortOwner = () => {
-      void this.close(this.#owner.reason).catch(() => {
-      });
-    };
-    options.registerCleanup?.(() => this.#terminal ?? this.close());
-    if (this.#owner?.aborted) this.#abortOwner();
-    else this.#owner?.addEventListener("abort", this.#abortOwner, { once: true });
-  }
-  limits;
-  #records = /* @__PURE__ */ new Map();
-  #jobs = /* @__PURE__ */ new Map();
-  #listeners = /* @__PURE__ */ new Set();
-  #owner;
-  #abortOwner;
-  #accepting = true;
-  #cancelling = false;
-  #finished = false;
-  #waiters = 0;
-  #terminal;
-  async start(prepare) {
-    this.#owner?.throwIfAborted();
-    if (!this.#accepting) throw new Error("job state is closed to admission");
-    if (typeof prepare !== "function") throw new TypeError("job preparation must be a function");
-    if (this.#records.size >= this.limits.maxJobs) throw new Error("job limit exceeded: maxJobs");
-    const occupied = [...this.#records.values()].filter((record2) => record2.state === "preparing" || record2.listed && !this.#canRetire(record2));
-    const jobId = Math.max(0, ...occupied.map((record2) => record2.handle.jobId)) + 1;
-    if (!Number.isSafeInteger(jobId)) throw new Error("job ID exhausted");
-    let complete;
-    const completion = new Promise((resolve) => {
-      complete = resolve;
-    });
-    const handle = Object.freeze({ jobId, completion });
-    const record = {
-      handle,
-      complete,
-      controller: new AbortController(),
-      cleanups: [],
-      cleanupFailures: [],
-      listed: false,
-      notified: false,
-      saved: false,
-      state: "preparing"
-    };
-    this.#records.set(handle, record);
-    this.#notify();
-    const context = Object.freeze({
-      signal: record.controller.signal,
-      registerCleanup: (cleanup) => {
-        if (record.cleaning || record.controller.signal.aborted || record.state === "done") throw new Error("job cleanup admission is closed");
-        if (typeof cleanup !== "function") throw new TypeError("job cleanup must be a function");
-        if (record.cleanups.length >= this.limits.maxCleanupsPerJob) throw new Error("job limit exceeded: maxCleanupsPerJob");
-        record.cleanups.push(cleanup);
-      }
-    });
-    let run;
-    let failure;
-    try {
-      const prepared = await prepare(context);
-      if (!record.controller.signal.aborted) {
-        const runner = prepared?.run;
-        if (typeof runner !== "function") throw new TypeError("job preparation must return a runner");
-        run = () => Reflect.apply(runner, prepared, []);
-      }
-    } catch (reason) {
-      failure = { reason };
-    }
-    if (failure || record.controller.signal.aborted) {
-      await this.#settle(record, failure);
-      this.#forget(record);
-      throw record.outcome.reason;
-    }
-    this.retireNotified();
-    record.listed = true;
-    this.#jobs.set(jobId, record);
-    this.#notify();
-    queueMicrotask(() => {
-      void this.#execute(record, run);
-    });
-    return handle;
-  }
-  async #execute(record, run) {
-    let result = 0;
-    let failure;
-    if (!record.controller.signal.aborted) {
-      record.state = "running";
-      this.#notify();
-      try {
-        result = await run();
-        if (!Number.isInteger(result) || result < 0 || result > 255) throw new TypeError("job exit status must be an integer from 0 to 255");
-      } catch (reason) {
-        failure = { reason };
-      }
-    }
-    await this.#settle(record, failure, result);
-  }
-  #clean(record) {
-    if (!record.cleaning) {
-      record.cleaning = Promise.resolve().then(async () => {
-        const results = await Promise.allSettled(record.cleanups.map(async (cleanup) => cleanup()));
-        for (const result of results) if (result.status === "rejected") record.cleanupFailures.push(result.reason);
-        record.cleanups.length = 0;
-      });
-    }
-    return record.cleaning;
-  }
-  async #settle(record, failure, result = 0) {
-    await this.#clean(record);
-    let outcome;
-    if (this.#owner?.aborted) outcome = { kind: "failure", reason: this.#owner.reason };
-    else if (record.terminationStatus !== void 0 && (!failure || failure.reason === record.controller.signal.reason)) {
-      outcome = record.cleanupFailures.length ? { kind: "failure", reason: record.cleanupFailures[0] } : { kind: "status", status: record.terminationStatus };
-    } else if (failure) outcome = { kind: "failure", reason: failure.reason };
-    else if (record.controller.signal.aborted) outcome = { kind: "failure", reason: record.controller.signal.reason };
-    else if (record.cleanupFailures.length) outcome = { kind: "failure", reason: record.cleanupFailures[0] };
-    else outcome = { kind: "status", status: result };
-    record.outcome = Object.freeze(outcome);
-    record.state = "done";
-    record.complete(record.outcome);
-    this.#notify();
-  }
-  #unlist(record) {
-    record.listed = false;
-    if (this.#jobs.get(record.handle.jobId) === record) this.#jobs.delete(record.handle.jobId);
-  }
-  #forget(record) {
-    this.#unlist(record);
-    this.#records.delete(record.handle);
-    this.#notify();
-  }
-  #notify() {
-    for (const listener of [...this.#listeners]) listener();
-  }
-  snapshot() {
-    return Object.freeze([...this.#records.values()].map((record) => Object.freeze({
-      handle: record.handle,
-      listed: record.listed,
-      notified: record.notified,
-      state: record.state,
-      residency: record.saved ? "saved" : record.notified ? "active-notified" : "active-unnotified",
-      ...record.outcome === void 0 ? {} : { outcome: record.outcome }
-    })));
-  }
-  #canRetire(record) {
-    return !record.saved && record.state === "done" && record.notified && record.outcome?.kind === "status";
-  }
-  retireNotified() {
-    let changed = false;
-    for (const record of this.#records.values()) {
-      if (this.#canRetire(record)) {
-        record.saved = true;
-        this.#unlist(record);
-        changed = true;
-      }
-    }
-    if (changed) this.#notify();
-  }
-  savedStatus(handle) {
-    const record = this.#records.get(handle);
-    return record?.saved && record.outcome?.kind === "status" ? record.outcome.status : void 0;
-  }
-  disown(handle) {
-    const record = this.#records.get(handle);
-    if (!record || !record.listed) return false;
-    this.#unlist(record);
-    record.saved = true;
-    this.#notify();
-    return true;
-  }
-  signal(handle, signal) {
-    if (!Number.isInteger(signal) || signal < 0 || signal > 31) throw new TypeError("invalid job signal");
-    const record = this.#records.get(handle);
-    if (!record || record.state === "done") return false;
-    if (signal !== 0) {
-      record.terminationStatus ??= 128 + signal;
-      record.controller.abort(new Error(`Job terminated by signal ${signal}`));
-    }
-    return true;
-  }
-  #targets(targets) {
-    if (targets === void 0) return void 0;
-    if (!Array.isArray(targets)) throw new TypeError("job targets must be an array");
-    if (targets.length === 0) return void 0;
-    if (targets.length > this.limits.maxJobs) throw new Error("job target limit exceeded");
-    const selected = [];
-    for (let index = 0; index < targets.length; index++) {
-      const target = targets[index];
-      if (!target || typeof target !== "object" || Reflect.ownKeys(target).length !== 1) throw new TypeError("invalid job target");
-      if ("jobId" in target && Number.isSafeInteger(target.jobId) && target.jobId > 0) selected.push(Object.freeze({ jobId: target.jobId }));
-      else if ("handle" in target && target.handle && typeof target.handle === "object") selected.push(Object.freeze({ handle: target.handle }));
-      else throw new TypeError("invalid job target");
-    }
-    return selected;
-  }
-  #lookup(target) {
-    return "handle" in target ? this.#records.get(target.handle) : this.#jobs.get(target.jobId);
-  }
-  #waitSignal(options) {
-    if (!options || typeof options !== "object" || Reflect.ownKeys(options).some((key) => key !== "signal")) throw new TypeError("invalid job wait options");
-    if (options.signal !== void 0 && !(options.signal instanceof AbortSignal)) throw new TypeError("invalid job wait signal");
-    options.signal?.throwIfAborted();
-    return options.signal;
-  }
-  #changed(signal) {
-    return new Promise((resolve, reject) => {
-      const cleanup = () => {
-        this.#listeners.delete(changed);
-        signal?.removeEventListener("abort", aborted);
-      };
-      const changed = () => {
-        cleanup();
-        resolve();
-      };
-      const aborted = () => {
-        cleanup();
-        reject(signal.reason);
-      };
-      this.#listeners.add(changed);
-      if (signal?.aborted) aborted();
-      else signal?.addEventListener("abort", aborted, { once: true });
-    });
-  }
-  async wait(targets, options = {}) {
-    const selected = this.#targets(targets);
-    const signal = this.#waitSignal(options);
-    if (this.#waiters >= this.limits.maxWaiters) throw new Error("job limit exceeded: maxWaiters");
-    this.#waiters++;
-    const unknown = [];
-    let outcome = Object.freeze({ kind: "status", status: 0 });
-    let failure;
-    try {
-      if (selected === void 0) {
-        const records = [...this.#records.values()];
-        for (const record of records) {
-          while (record.state !== "done") {
-            signal?.throwIfAborted();
-            await this.#changed(signal);
-          }
-          if (record.outcome.kind === "failure") failure ??= record.outcome;
-        }
-        signal?.throwIfAborted();
-        for (const record of records) this.#forget(record);
-      } else for (const target of selected) {
-        signal?.throwIfAborted();
-        const record = this.#lookup(target);
-        if (!record) {
-          unknown.push(target);
-          outcome = Object.freeze({ kind: "status", status: 127 });
-          continue;
-        }
-        while (record.state !== "done") {
-          signal?.throwIfAborted();
-          await this.#changed(signal);
-        }
-        signal?.throwIfAborted();
-        if (!record.saved) this.retireNotified();
-        record.notified = true;
-        if ("handle" in target) this.#unlist(record);
-        outcome = record.outcome;
-        if (outcome.kind === "failure") failure ??= outcome;
-        this.#notify();
-      }
-      return Object.freeze({ outcome: failure ?? outcome, unknown: Object.freeze(unknown) });
-    } finally {
-      this.#waiters--;
-    }
-  }
-  async waitNext(targets, options = {}) {
-    const selected = this.#targets(targets);
-    const signal = this.#waitSignal(options);
-    if (this.#waiters >= this.limits.maxWaiters) throw new Error("job limit exceeded: maxWaiters");
-    this.#waiters++;
-    const unknown = [];
-    const records = /* @__PURE__ */ new Set();
-    if (selected === void 0) {
-      for (const record of this.#records.values()) if (!record.saved) records.add(record);
-    } else for (const target of selected) {
-      const record = this.#lookup(target);
-      if (!record || record.saved) unknown.push(target);
-      else records.add(record);
-    }
-    try {
-      for (; ; ) {
-        signal?.throwIfAborted();
-        const eligible = [...records].filter((record) => !record.saved && !record.notified).sort((first, second) => first.handle.jobId - second.handle.jobId);
-        const ready = eligible.find((record) => record.state === "done");
-        if (ready) {
-          ready.notified = true;
-          ready.saved = ready.outcome.kind === "status";
-          this.#unlist(ready);
-          this.#notify();
-          return Object.freeze({ outcome: ready.outcome, handle: ready.handle, unknown: Object.freeze(unknown) });
-        }
-        if (!eligible.length) return Object.freeze({ outcome: Object.freeze({ kind: "status", status: 127 }), unknown: Object.freeze(unknown) });
-        await this.#changed(signal);
-      }
-    } finally {
-      this.#waiters--;
-    }
-  }
-  finish() {
-    this.#accepting = false;
-    return this.#drain();
-  }
-  close(reason = new Error("job state closed")) {
-    this.#accepting = false;
-    if (!this.#finished && !this.#cancelling) {
-      this.#cancelling = true;
-      for (const record of this.#records.values()) if (record.state !== "done") {
-        record.controller.abort(reason);
-        void this.#clean(record);
-      }
-    }
-    return this.#drain();
-  }
-  #drain() {
-    if (!this.#terminal) {
-      const records = [...this.#records.values()];
-      this.#terminal = (async () => {
-        try {
-          await Promise.all(records.map((record) => record.handle.completion));
-          if (!this.#cancelling) {
-            const failure = records.find((record) => record.outcome?.kind === "failure");
-            if (failure?.outcome?.kind === "failure") throw failure.outcome.reason;
-          }
-          const errors = records.flatMap((record) => record.cleanupFailures);
-          if (errors.length) throw new AggregateError(errors, "job cleanup failed");
-        } finally {
-          this.#finished = true;
-          this.#owner?.removeEventListener("abort", this.#abortOwner);
-        }
-      })();
-      void this.#terminal.catch(() => {
-      });
-    }
-    return this.#terminal;
-  }
-};
-function createJobState(options = {}) {
-  if (!options || typeof options !== "object" || Array.isArray(options)) throw new TypeError("invalid job options");
-  const limits = { maxJobs: Infinity, maxWaiters: Infinity, maxCleanupsPerJob: Infinity };
-  for (const key of Reflect.ownKeys(options)) {
-    if (key === "signal" || key === "registerCleanup") continue;
-    if (typeof key !== "string" || !Object.hasOwn(limits, key)) throw new TypeError("unknown job option");
-    const name = key;
-    const value = options[name];
-    if (value === void 0) continue;
-    if (!Number.isSafeInteger(value) || value < 1) throw new TypeError(`invalid job limit: ${key}`);
-    limits[name] = value;
-  }
-  if (options.signal !== void 0 && !(options.signal instanceof AbortSignal)) throw new TypeError("invalid job owner signal");
-  if (options.registerCleanup !== void 0 && typeof options.registerCleanup !== "function") throw new TypeError("invalid job owner cleanup registration");
-  return new JobRegistry(Object.freeze(limits), options);
-}
-
-// packages/safe-bash/src/shell/extensions/jobs/index.ts
-var maximumWaitProcessId = 2147483647;
-function waitProcessId(operand, flexible = false) {
-  let value = 0;
-  let offset = 0;
-  let negative = false;
-  if (flexible) {
-    while (offset < operand.length && (operand.charCodeAt(offset) === 32 || operand.charCodeAt(offset) >= 9 && operand.charCodeAt(offset) <= 13)) offset++;
-    if (operand[offset] === "+" || operand[offset] === "-") negative = operand[offset++] === "-";
-  }
-  const firstDigit = offset;
-  while (offset < operand.length) {
-    const code = operand.charCodeAt(offset);
-    if (code < 48 || code > 57) break;
-    value = value * 10 + code - 48;
-    if (value > maximumWaitProcessId + Number(negative)) return void 0;
-    offset++;
-  }
-  if (offset === firstDigit) return void 0;
-  while (offset < operand.length) {
-    const code = operand.charCodeAt(offset++);
-    if (code !== 32 && (code < 9 || code > 13)) return void 0;
-  }
-  return negative ? -value : value;
-}
-function instance(inherited, getParent) {
-  let latest = inherited;
-  let jobs;
-  let failure;
-  const children = /* @__PURE__ */ new Map();
-  const resolveFrom = (activeJobs, activeChildren, operand, flexible = false) => {
-    if (!operand.startsWith("%")) {
-      const processId = waitProcessId(operand, flexible);
-      return processId === void 0 ? void 0 : activeChildren.get(processId);
-    }
-    const listed = activeJobs.snapshot().filter((entry) => entry.listed);
-    const spec = operand.slice(1);
-    if (spec === "" || spec === "%" || spec === "+") return listed.at(-1)?.handle;
-    if (spec === "-") return listed.at(-2)?.handle;
-    const jobId = waitProcessId(spec);
-    return listed.find((entry) => entry.handle.jobId === jobId)?.handle;
-  };
-  const resolve = (operand, flexible = false) => resolveFrom(jobs, children, operand, flexible);
-  const list = async (context) => {
-    let mode = "", offset = 0;
-    for (; offset < context.args.length; offset++) {
-      const option = context.args[offset];
-      if (option === "--") {
-        offset++;
-        break;
-      }
-      if (!option.startsWith("-")) break;
-      if (option === "-p" || option === "-l" || option === "-r" || option === "-s") mode = option;
-      else {
-        await context.diagnostic(`jobs: ${option}: invalid option`);
-        return 2;
-      }
-    }
-    let activeJobs = jobs;
-    let activeChildren = children;
-    let listed = activeJobs.snapshot().filter((entry) => entry.listed);
-    if (listed.length === 0 && getParent) {
-      const parent = getParent();
-      if (parent.jobs) {
-        activeJobs = parent.jobs;
-        activeChildren = parent.children;
-        listed = activeJobs.snapshot().filter((entry) => entry.listed);
-      }
-    }
-    let result = 0;
-    const selected = offset === context.args.length ? listed.map((entry) => entry.handle) : context.args.slice(offset).map((operand) => resolveFrom(activeJobs, activeChildren, operand.startsWith("%") ? operand : `%${operand}`));
-    for (const [index, handle] of selected.entries()) {
-      if (!handle) {
-        await context.diagnostic(`jobs: ${context.args[offset + index]}: no such job`);
-        result = 1;
-        continue;
-      }
-      const entry = listed.find((entry2) => entry2.handle === handle);
-      if (!entry || mode === "-s" || mode === "-r" && entry.state === "done") continue;
-      const pid = [...activeChildren].find(([, child]) => child === handle)?.[0];
-      if (mode === "-p") await (0, io_exports.writeText)(context.stdout, `${pid}
-`);
-      else {
-        const marker = handle === listed.at(-1)?.handle ? "+" : handle === listed.at(-2)?.handle ? "-" : " ";
-        const state = entry.state === "done" ? "Done" : "Running";
-        await (0, io_exports.writeText)(context.stdout, `[${handle.jobId}]${marker} ${mode === "-l" ? `${pid} ` : ""}${state}
-`);
-      }
-    }
-    return result;
-  };
-  const kill = async (context) => {
-    const signals = Object.fromEntries(Array.from({ length: 31 }, (_, index) => [`SIG${signalName(index + 1)}`, index + 1]));
-    const signalNumber = (name) => {
-      const numeric = waitProcessId(name);
-      if (numeric !== void 0) return numeric === 0 || Object.values(signals).includes(numeric) ? numeric : void 0;
-      return signals[name.startsWith("SIG") ? name : `SIG${name}`];
-    };
-    let offset = 0, signal = signals.SIGTERM;
-    if (context.args[0] === "-l" || context.args[0] === "-L") {
-      if (context.args.length === 1) {
-        await (0, io_exports.writeText)(context.stdout, `${Object.keys(signals).map((name) => name.slice(3)).join(" ")}
-`);
-        return 0;
-      }
-      let result2 = 0;
-      for (const operand of context.args.slice(1)) {
-        const numeric = waitProcessId(operand);
-        const number = numeric === void 0 ? signalNumber(operand) : numeric > 128 ? numeric - 128 : numeric;
-        const name = Object.keys(signals).find((name2) => signals[name2] === number);
-        if (!name) {
-          await context.diagnostic(`kill: ${operand}: invalid signal specification`);
-          result2 = 1;
-        } else await (0, io_exports.writeText)(context.stdout, `${numeric === void 0 ? number : name.slice(3)}
-`);
-      }
-      return result2;
-    }
-    if (context.args[0] === "-s" || context.args[0] === "-n") {
-      signal = signalNumber(context.args[1] ?? "");
-      offset = 2;
-    } else if (context.args[0]?.startsWith("-") && context.args[0] !== "--") {
-      signal = signalNumber(context.args[0].slice(1));
-      offset = 1;
-    }
-    if (context.args[offset] === "--") offset++;
-    if (signal === void 0 || signal > 31) {
-      await context.diagnostic("kill: invalid signal specification");
-      return 1;
-    }
-    if ([signals.SIGSTOP, signals.SIGTSTP, signals.SIGTTIN, signals.SIGTTOU, signals.SIGCONT, signals.SIGCHLD, signals.SIGURG, signals.SIGWINCH].includes(signal)) {
-      await context.diagnostic("kill: signal is not supported by virtual job termination");
-      return 1;
-    }
-    if (offset >= context.args.length) {
-      await context.diagnostic("kill: usage: kill [-s signal | -n signal | -signal] pid | %job ...");
-      return 2;
-    }
-    let result = 0;
-    for (const operand of context.args.slice(offset)) {
-      const handle = resolve(operand);
-      if (!handle || !jobs.signal(handle, signal)) {
-        await context.diagnostic(`kill: ${operand}: no such ${operand.startsWith("%") ? "job" : "process"}`);
-        result = 1;
-      }
-    }
-    return result;
-  };
-  const disown = async (context) => {
-    let all = false;
-    let runningOnly = false;
-    let nohupOnly = false;
-    let offset = 0;
-    for (; offset < context.args.length; offset++) {
-      const arg = context.args[offset];
-      if (arg === "--") {
-        offset++;
-        break;
-      }
-      if (!arg.startsWith("-") || arg === "-") break;
-      for (let i = 1; i < arg.length; i++) {
-        const ch = arg[i];
-        if (ch === "a") all = true;
-        else if (ch === "r") runningOnly = true;
-        else if (ch === "h") nohupOnly = true;
-        else {
-          await context.diagnostic(`disown: -${ch}: invalid option`);
-          return 2;
-        }
-      }
-    }
-    const listed = jobs.snapshot().filter((entry) => entry.listed);
-    const removeHandle = (handle) => {
-      if (nohupOnly) return;
-      jobs.disown(handle);
-      for (const [pid, child] of children) {
-        if (child === handle) children.delete(pid);
-      }
-    };
-    if (offset === context.args.length) {
-      if (all || runningOnly) {
-        for (const entry of listed) {
-          if (runningOnly && entry.state === "done") continue;
-          removeHandle(entry.handle);
-        }
-        return 0;
-      }
-      const current = listed.at(-1)?.handle;
-      if (!current) {
-        await context.diagnostic("disown: current: no such job");
-        return 1;
-      }
-      removeHandle(current);
-      return 0;
-    }
-    let statusCode = 0;
-    for (let i = offset; i < context.args.length; i++) {
-      const operand = context.args[i];
-      const handle = resolve(operand) ?? resolve(operand.startsWith("%") ? operand : `%${operand}`);
-      if (!handle) {
-        await context.diagnostic(`disown: ${operand}: no such job`);
-        statusCode = 1;
-        continue;
-      }
-      removeHandle(handle);
-    }
-    return statusCode;
-  };
-  const status = (outcome) => {
-    if (outcome.kind === "failure") {
-      failure ??= { reason: outcome.reason };
-      throw outcome.reason;
-    }
-    return outcome.status;
-  };
-  const wait = async (context) => {
-    let reference;
-    let primary;
-    const ordinaryWait = async (targets) => {
-      if (context.waitInterruptibly) return context.waitInterruptibly((signal) => jobs.wait(targets, { signal }));
-      return { kind: "completed", value: await jobs.wait(targets, { signal: context.signal }) };
-    };
-    const execute = async () => {
-      let offset = 0;
-      let next = false;
-      let destination;
-      while (offset < context.args.length) {
-        context.signal.throwIfAborted();
-        const option = (0, value_exports.shellValueBytes)(context.argumentValues[offset]);
-        if (option.length < 2 || option[0] !== 45) break;
-        offset++;
-        if (option.length === 2 && option[1] === 45) break;
-        for (let index = 1; index < option.length; index++) {
-          if (option[index] === 102) continue;
-          if (option[index] === 110) {
-            next = true;
-            continue;
-          }
-          if (option[index] === 112) {
-            if (index + 1 < option.length) destination = (0, value_exports.shellValueFromBytes)(option.subarray(index + 1));
-            else if (offset < context.args.length) destination = context.argumentValues[offset++];
-            else {
-              await context.diagnostic("wait: -p: option requires an argument");
-              await (0, io_exports.writeText)(context.stderr, "wait: usage: wait [-fn] [-p var] [id ...]\n");
-              return 2;
-            }
-            break;
-          }
-          await context.diagnostic((0, value_exports.concatShellValues)(["wait: -", (0, value_exports.shellValueFromBytes)(option.subarray(index, index + 1)), ": invalid option"]));
-          await (0, io_exports.writeText)(context.stderr, "wait: usage: wait [-fn] [-p var] [id ...]\n");
-          return 2;
-        }
-      }
-      if (destination !== void 0) {
-        const prepared = await context.bindings.prepareReference(destination);
-        if (!prepared.ok) {
-          await context.diagnostic((0, value_exports.concatShellValues)(["wait: ", prepared.diagnostic]));
-          return 1;
-        }
-        reference = prepared.value;
-        const removed = await reference.unbindName();
-        if (!removed.ok) {
-          await context.diagnostic((0, value_exports.concatShellValues)(["wait: ", removed.diagnostic]));
-          return 1;
-        }
-      }
-      const publish = async (result2, processId) => {
-        if (reference && processId !== void 0) {
-          const assigned = await reference.assignInteger(processId);
-          if (!assigned.ok) {
-            await context.diagnostic((0, value_exports.concatShellValues)(["wait: ", assigned.diagnostic]));
-            return 1;
-          }
-        }
-        return result2;
-      };
-      if (next) {
-        for (let index = offset; index < context.args.length; index++) {
-          context.signal.throwIfAborted();
-          const processId2 = waitProcessId(context.args[index], true);
-          const handle = resolve(context.args[index], true);
-          const saved = handle && jobs.savedStatus(handle);
-          if (saved !== void 0) return await publish(saved, processId2);
-        }
-        const active = new Set(jobs.snapshot().filter((entry) => entry.residency !== "saved").map((entry) => entry.handle));
-        const targets = [];
-        for (let index = offset; index < context.args.length; index++) {
-          context.signal.throwIfAborted();
-          const operand = context.args[index];
-          const raw = context.argumentValues[index];
-          const processId2 = waitProcessId(operand, true);
-          const handle = resolve(operand, true);
-          if (handle && active.has(handle)) {
-            targets.push({ handle });
-            continue;
-          }
-          if ((processId2 === void 0 || processId2 === -1) && operand.length && operand[0] !== "%") await context.diagnostic((0, value_exports.concatShellValues)(["wait: warning: ", raw, ": job specification requires leading `%'"]));
-          await context.diagnostic((0, value_exports.concatShellValues)(["wait: `", raw, operand[0] === "%" ? "': no such job" : "': not a pid or valid job spec"]));
-        }
-        if (offset < context.args.length && !targets.length) return 127;
-        const selected = offset === context.args.length ? void 0 : targets;
-        const waited2 = context.waitInterruptibly ? await context.waitInterruptibly((signal) => jobs.waitNext(selected, { signal })) : { kind: "completed", value: await jobs.waitNext(selected, { signal: context.signal }) };
-        if (waited2.kind === "interrupted") return waited2.status;
-        const result2 = status(waited2.value.outcome);
-        const processId = waited2.value.handle && [...children].find(([, handle]) => handle === waited2.value.handle)?.[0];
-        return await publish(result2, processId);
-      }
-      if (offset === context.args.length) {
-        const result2 = await ordinaryWait();
-        if (result2.kind === "interrupted") return result2.status;
-        children.clear();
-        return status(result2.value.outcome);
-      }
-      const waitOperands = async (signal) => {
-        let result2 = 0;
-        let returnedProcessId;
-        for (; offset < context.args.length; offset++) {
-          signal.throwIfAborted();
-          const operand = context.args[offset];
-          const raw = context.argumentValues[offset];
-          const processId = waitProcessId(operand);
-          returnedProcessId = void 0;
-          const handle = resolve(operand);
-          if (operand.startsWith("%") && !handle) {
-            await context.diagnostic((0, value_exports.concatShellValues)(["wait: `", raw, "': no such job"]));
-            result2 = 127;
-            continue;
-          }
-          if (processId === void 0 && !operand.startsWith("%")) {
-            await context.diagnostic((0, value_exports.concatShellValues)(["wait: `", raw, "': not a pid or valid job spec"]));
-            if (operand.length && operand[0] >= "0" && operand[0] <= "9") return { result: 1, processId: void 0 };
-            result2 = 1;
-            continue;
-          }
-          if (!handle) {
-            await context.diagnostic(`wait: pid ${processId} is not a child of this shell`);
-            result2 = 127;
-          } else {
-            const waited2 = await jobs.wait([{ handle }], { signal });
-            result2 = status(waited2.outcome);
-            returnedProcessId = [...children].find(([, child]) => child === handle)?.[0];
-          }
-        }
-        return { result: result2, processId: returnedProcessId };
-      };
-      const waited = context.waitInterruptibly ? await context.waitInterruptibly(waitOperands) : { kind: "completed", value: await waitOperands(context.signal) };
-      if (waited.kind === "interrupted") return waited.status;
-      return await publish(waited.value.result, waited.value.processId);
-    };
-    let result = 0;
-    try {
-      result = await execute();
-    } catch (reason) {
-      primary = { reason };
-      failure ??= primary;
-    }
-    try {
-      await reference?.close();
-    } catch (reason) {
-      primary ??= { reason };
-      failure ??= primary;
-    }
-    if (primary) throw primary.reason;
-    return result;
-  };
-  const extInstance = {
-    builtins: [{ name: "wait", execute: wait }, { name: "jobs", execute: list }, { name: "kill", execute: kill }, { name: "disown", execute: disown }],
-    start(context) {
-      const registerExecutionCleanup = context.registerExecutionCleanup;
-      if (typeof registerExecutionCleanup !== "function") throw new TypeError("Jobs require execution-scoped cleanup ownership");
-      let ownerSignal = context.signal;
-      let retired;
-      const retirement = new Promise((resolve2) => {
-        retired = resolve2;
-      });
-      let completion;
-      const finish = () => {
-        retired();
-        if (!completion) {
-          completion = Promise.resolve().then(async () => {
-            if (jobs) {
-              try {
-                if (ownerSignal.aborted) await jobs.close(ownerSignal.reason);
-                else await jobs.finish();
-              } catch (reason) {
-                failure ??= { reason };
-              }
-            }
-            if (failure) throw failure.reason;
-          });
-          void completion.catch(() => void 0);
-        }
-        return completion;
-      };
-      try {
-        const signal = registerExecutionCleanup.call(context, async () => {
-          try {
-            await retirement;
-            await finish();
-          } finally {
-            ownerSignal.removeEventListener("abort", retired);
-          }
-        });
-        if (!(signal instanceof AbortSignal)) throw new TypeError("Execution cleanup must provide its owner cancellation signal");
-        ownerSignal = signal;
-        ownerSignal.addEventListener("abort", retired, { once: true });
-        if (ownerSignal.aborted) retired();
-        context.registerCleanup(() => {
-          void finish();
-        });
-        jobs = createJobState({ signal: ownerSignal });
-      } catch (reason) {
-        void finish();
-        throw reason;
-      }
-    },
-    fork: () => instance(latest, () => ({ jobs, children })),
-    checkpoint() {
-      jobs.retireNotified();
-    },
-    listTerminators: [{ operator: "&", async execute(context) {
-      let processId;
-      const handle = await jobs.start(async (task) => {
-        const child = await context.prepareChild({ ...task, stdin: "async-default" });
-        processId = child.processId;
-        return child;
-      });
-      children.set(processId, handle);
-      latest = processId;
-      return 0;
-    } }],
-    specialParameters: [{ name: "!", lookup: () => latest === void 0 ? void 0 : String(latest) }]
-  };
-  return extInstance;
-}
-function jobsExtension() {
-  return {
-    name: "jobs",
-    runtimeIdentity: command_exports.commandRuntimeIdentity,
-    syntax: { listTerminators: [{ operator: "&" }], specialParameters: [{ name: "!" }] },
-    create: () => instance()
-  };
-}
-
-export {
-  signalName,
-  parseSignal,
-  jobsExtension
-};
-//# sourceMappingURL=chunk-LB6HVRXS.js.map