@poe-platform/safe-bash 0.1.153 → 0.1.155

package/dist/safe-bash/browser.d.ts

@@ -19,6 +19,7 @@ export interface BrowserCommandsOptions {
     readonly replace?: boolean;
     readonly maxDirectoryEntries?: number;
     readonly maxTeeTargets?: number;
+    readonly maxTailFollowHandles?: number;
 }
 export declare function createBrowserCommands(options?: BrowserCommandsOptions): readonly CommandDefinition[];
 export declare function browserCommands(options?: BrowserCommandsOptions): VirtualShellPlugin;

package/dist/safe-bash/browser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../src/browser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAMlF,OAAO,EAAqC,KAAK,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AAG3G,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,OAAO,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAC7E,YAAY,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAC;AACnF,OAAO,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAC1E,YAAY,EAAE,eAAe,EAAE,uBAAuB,EAAE,MAAM,kCAAkC,CAAC;AACjG,OAAO,EAAE,6BAA6B,EAAE,MAAM,6BAA6B,CAAC;AAC5E,OAAO,EAAE,sBAAsB,EAAE,KAAK,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AACnG,cAAc,sCAAsC,CAAC;AACrD,YAAY,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AAExE,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,SAAS,CAAC,EAAE,wBAAwB,CAAC;IAC9C,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAC;IACtC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;CACjC;AAED,wBAAgB,qBAAqB,CAAC,OAAO,GAAE,sBAA2B,GAAG,SAAS,iBAAiB,EAAE,CAYxG;AAED,wBAAgB,eAAe,CAAC,OAAO,GAAE,sBAA2B,GAAG,kBAAkB,CAaxF"}
+{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../src/browser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAMlF,OAAO,EAAqC,KAAK,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AAG3G,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,OAAO,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAC7E,YAAY,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAC;AACnF,OAAO,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAC1E,YAAY,EAAE,eAAe,EAAE,uBAAuB,EAAE,MAAM,kCAAkC,CAAC;AACjG,OAAO,EAAE,6BAA6B,EAAE,MAAM,6BAA6B,CAAC;AAC5E,OAAO,EAAE,sBAAsB,EAAE,KAAK,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AACnG,cAAc,sCAAsC,CAAC;AACrD,YAAY,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AAExE,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,SAAS,CAAC,EAAE,wBAAwB,CAAC;IAC9C,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAC;IACtC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,oBAAoB,CAAC,EAAE,MAAM,CAAC;CACxC;AAED,wBAAgB,qBAAqB,CAAC,OAAO,GAAE,sBAA2B,GAAG,SAAS,iBAAiB,EAAE,CAYxG;AAED,wBAAgB,eAAe,CAAC,OAAO,GAAE,sBAA2B,GAAG,kBAAkB,CAaxF"}

package/dist/safe-bash/browser.js

@@ -4373,6 +4373,434 @@ async function openFileOutput(context, path, flag, incremental) {
   }
 }
 
+// packages/safe-bash/src/commands/tail-follow.ts
+init_platform();
+var tailFollowScheduler = {
+  now: monotonicNow,
+  setTimeout: (callback, milliseconds) => setTimeout(callback, milliseconds),
+  clearTimeout: (handle) => clearTimeout(handle)
+};
+function parseTailFollow(arguments_) {
+  const args = [];
+  let mode;
+  let idleMs;
+  let ended = false;
+  for (let index = 0; index < arguments_.length; index++) {
+    const argument = arguments_[index];
+    if (ended || argument === "-" || !argument.startsWith("-")) {
+      args.push(argument);
+      continue;
+    }
+    if (argument === "--") {
+      ended = true;
+      args.push(argument);
+      continue;
+    }
+    if (argument === "--max-idle" || argument.startsWith("--max-idle=")) {
+      const text = argument === "--max-idle" ? arguments_[++index] : argument.slice(11);
+      if (text === void 0 || !/^(?:[0-9]+(?:\.[0-9]+)?|\.[0-9]+)$/u.test(text)) throw new UsageError("max-idle must be nonnegative decimal seconds");
+      const [whole = "", fraction = ""] = text.split(".");
+      if (fraction.slice(3).split("").some((digit2) => digit2 !== "0")) throw new UsageError("max-idle must resolve to integer milliseconds");
+      const milliseconds = BigInt(whole || "0") * 1000n + BigInt(fraction.slice(0, 3).padEnd(3, "0"));
+      if (milliseconds > BigInt(Number.MAX_SAFE_INTEGER)) throw new UsageError("max-idle exceeds safe milliseconds");
+      idleMs = Number(milliseconds);
+    } else if (argument.startsWith("--")) {
+      args.push(argument);
+      if ((argument === "--lines" || argument === "--bytes") && index + 1 < arguments_.length) args.push(arguments_[++index]);
+    } else {
+      let kept = "-";
+      for (let offset = 1; offset < argument.length; offset++) {
+        const flag = argument[offset];
+        if (flag === "f" || flag === "F") mode = flag;
+        else {
+          kept += flag;
+          if (flag === "n" || flag === "c") {
+            kept += argument.slice(offset + 1);
+            if (offset + 1 === argument.length && index + 1 < arguments_.length) {
+              args.push(kept, arguments_[++index]);
+              kept = "-";
+            }
+            break;
+          }
+        }
+      }
+      if (kept !== "-") args.push(kept);
+    }
+  }
+  if (idleMs !== void 0 && mode === void 0) throw new UsageError("max-idle requires -f or -F");
+  return { args, mode, idleMs };
+}
+var idleExpired = /* @__PURE__ */ Symbol("tail idle expired");
+var FollowSession = class {
+  constructor(caller, cap, scheduler) {
+    this.caller = caller;
+    this.cap = cap;
+    this.scheduler = scheduler;
+    this.operation = createOutputOperation(caller, caller.stdout);
+    this.context = { ...caller, stdout: this.operation.output, signal: this.operation.signal };
+    this.operation.registerCleanup(() => this.close());
+  }
+  caller;
+  cap;
+  scheduler;
+  operation;
+  context;
+  readers = /* @__PURE__ */ new Set();
+  pending = /* @__PURE__ */ new Set();
+  waiting = /* @__PURE__ */ new Set();
+  failures = [];
+  accepting = true;
+  opening = 0;
+  closeFailed = false;
+  drain;
+  stdin;
+  assertOpen() {
+    this.caller.signal.throwIfAborted();
+    this.operation.signal.throwIfAborted();
+    if (!this.accepting || this.closeFailed) throw new Error("Tail follow admission is closed");
+  }
+  wait(pending, milliseconds) {
+    this.assertOpen();
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      let timer;
+      let armed = false;
+      const finish = (outcome) => {
+        if (settled) return;
+        settled = true;
+        this.waiting.delete(cancel);
+        this.operation.signal.removeEventListener("abort", cancel);
+        try {
+          if (armed) this.scheduler.clearTimeout(timer);
+        } catch (reason) {
+          this.failures.push(reason);
+          if (!("reason" in outcome)) outcome = { reason };
+        }
+        if ("reason" in outcome) reject(outcome.reason);
+        else resolve(outcome.value);
+      };
+      const cancel = () => finish({ reason: this.operation.signal.aborted ? this.operation.signal.reason : new Error("Tail follow is closed") });
+      this.waiting.add(cancel);
+      this.operation.signal.addEventListener("abort", cancel, { once: true });
+      pending?.then((value2) => finish({ value: value2 }), (reason) => finish({ reason }));
+      if (milliseconds !== void 0) {
+        try {
+          timer = this.scheduler.setTimeout(() => finish({ value: idleExpired }), Math.min(2147483647, Math.max(0, milliseconds)));
+          armed = true;
+        } catch (reason) {
+          finish({ reason });
+        }
+      }
+      if (this.operation.signal.aborted || !this.accepting) cancel();
+    });
+  }
+  async work(start) {
+    this.assertOpen();
+    const pending = Promise.resolve().then(() => {
+      this.assertOpen();
+      return start();
+    });
+    const settled = pending.then(() => {
+    }, () => {
+    });
+    this.pending.add(settled);
+    void settled.then(() => {
+      this.pending.delete(settled);
+    });
+    return await this.wait(pending);
+  }
+  async open(name2) {
+    this.assertOpen();
+    if (this.readers.size + this.opening >= this.cap) throw new FsError("EMFILE", { message: "maxTailFollowHandles exhausted" });
+    this.opening++;
+    try {
+      return await this.work(async () => {
+        const path = pathOf(this.context, name2);
+        const capabilities = await this.caller.fs.capabilitiesFor?.(path, { signal: this.operation.signal }) ?? this.caller.fs.capabilities;
+        this.assertOpen();
+        if (capabilities.retainedRead !== true || typeof this.caller.fs.openReadFile !== "function") throw new FsError("ENOTSUP", { path, message: "tail follow requires retainedRead and openReadFile" });
+        const handle = await this.caller.fs.openReadFile(path, { signal: this.operation.signal });
+        const reader = { handle };
+        this.readers.add(reader);
+        if (!this.accepting || this.operation.signal.aborted) {
+          await this.release(reader);
+          this.assertOpen();
+        }
+        return reader;
+      });
+    } finally {
+      this.opening--;
+    }
+  }
+  release(reader) {
+    reader.closing ??= Promise.resolve().then(() => reader.handle.close()).then(() => {
+      this.readers.delete(reader);
+    }, (reason) => {
+      this.closeFailed = true;
+      this.failures.push(reason);
+      throw reason;
+    });
+    void reader.closing.catch(() => {
+    });
+    return reader.closing;
+  }
+  async stat(reader) {
+    const stat = await this.work(() => reader.handle.stat({ signal: this.operation.signal }));
+    if (stat.type !== "file") throw new FsError("EISDIR");
+    if (!Number.isSafeInteger(stat.size) || stat.size < 0) throw new FsError("EIO", { message: "invalid retained file size" });
+    return stat;
+  }
+  async read(reader, offset, end) {
+    const maximum = Math.min(64 * 1024, end - offset);
+    const chunk = await this.work(() => reader.handle.read(offset, maximum, { signal: this.operation.signal }));
+    if (!(chunk instanceof Uint8Array) || chunk.byteLength > maximum) throw new FsError("EIO", { message: "invalid retained read result" });
+    return chunk;
+  }
+  closeInput() {
+    const stdin = this.stdin;
+    if (!stdin) return Promise.resolve();
+    stdin.closing ??= Promise.resolve().then(async () => {
+      if (!stdin.finished) await stdin.iterator.return?.();
+    }).catch((reason) => {
+      this.failures.push(reason);
+      throw reason;
+    });
+    void stdin.closing.catch(() => {
+    });
+    return stdin.closing;
+  }
+  async *input(idleMs) {
+    this.assertOpen();
+    const stdin = { iterator: this.caller.stdin[Symbol.asyncIterator](), finished: false };
+    this.stdin = stdin;
+    let deadline = idleMs === void 0 ? void 0 : this.scheduler.now() + idleMs;
+    let failed = false;
+    try {
+      while (true) {
+        const pending = Promise.resolve().then(() => {
+          this.assertOpen();
+          return stdin.iterator.next();
+        });
+        const result = await this.wait(pending, deadline === void 0 ? void 0 : Math.max(0, deadline - this.scheduler.now()));
+        if (result === idleExpired) break;
+        if (result.done) {
+          stdin.finished = true;
+          break;
+        }
+        if (!(result.value instanceof Uint8Array)) throw new TypeError("Shell stdin must yield Uint8Array");
+        yield result.value;
+        if (result.value.byteLength && idleMs !== void 0) deadline = this.scheduler.now() + idleMs;
+        await yieldTurn(this.caller.signal);
+      }
+    } catch (reason) {
+      failed = true;
+      throw reason;
+    } finally {
+      await this.closeInput().catch((reason) => {
+        if (!failed) throw reason;
+      });
+    }
+  }
+  close() {
+    if (!this.drain) {
+      this.accepting = false;
+      for (const cancel of this.waiting) cancel();
+      this.drain = Promise.resolve().then(async () => {
+        await Promise.allSettled([...this.pending, ...[...this.readers].map((reader) => this.release(reader)), this.closeInput()]);
+        if (this.failures.length === 1) throw this.failures[0];
+        if (this.failures.length) throw new AggregateError(this.failures, "Tail follow cleanup failed");
+      });
+    }
+    return this.drain;
+  }
+};
+var FollowReadError = class {
+  constructor(reason) {
+    this.reason = reason;
+  }
+  reason;
+};
+async function followTail(caller, selection, cap, select, scheduler = tailFollowScheduler) {
+  const named = selection.names.filter((name2) => name2 !== "-").length;
+  if (named + Number(selection.mode === "F" && named > 0) > cap) throw new UsageError(`maxTailFollowHandles exceeded (limit ${cap})`);
+  if (selection.mode === "F" && selection.names.includes("-")) throw new FsError("ENOTSUP", { message: "cannot follow standard input by name" });
+  const session = new FollowSession(caller, cap, scheduler);
+  const context = session.context;
+  const entries = selection.names.map((name2) => ({ name: name2, reader: void 0, identity: void 0, offset: 0, error: void 0, active: name2 !== "-" }));
+  let lastHeader;
+  let exitCode = 0;
+  let primary;
+  let acknowledged = scheduler.now();
+  const header = async (entry) => {
+    if (selection.headers && lastHeader !== entry) {
+      await output(context, `${lastHeader ? "\n" : ""}==> ${entry.name === "-" ? "standard input" : entry.name} <==
+`);
+      lastHeader = entry;
+    }
+  };
+  const failure = async (entry, reason, initial) => {
+    session.assertOpen();
+    if (!(reason instanceof FsError) || !["ENOENT", "ENOTDIR", "EACCES", "EPERM", "EISDIR"].includes(reason.code)) throw reason;
+    if (initial) exitCode = 1;
+    if (initial && reason.code === "EISDIR" || !initial && reason.code === "EACCES" && entry.reader) await header(entry);
+    if (entry.error !== reason.code) await diagnostic(context, reason);
+    entry.error = reason.code;
+    if (entry.reader) {
+      await session.release(entry.reader);
+      entry.reader = void 0;
+    }
+    if (selection.mode === "f") {
+      entry.active = false;
+      exitCode = 1;
+    }
+  };
+  const acquire = async (entry, initial) => {
+    let candidate;
+    let stat;
+    try {
+      candidate = await session.open(entry.name);
+      stat = await session.stat(candidate);
+      if (selection.mode === "F" && compareCopyIdentity(stat, stat) === "unknown") throw new FsError("ENOTSUP", { path: entry.name, message: "name follow requires complete retained identity" });
+    } catch (reason) {
+      if (candidate) {
+        try {
+          await session.release(candidate);
+        } catch {
+          throw reason;
+        }
+      }
+      await failure(entry, reason, initial);
+      return void 0;
+    }
+    if (entry.reader && compareCopyIdentity(entry.identity, stat) === "same") {
+      await session.release(candidate);
+      return stat;
+    }
+    const replaced = entry.reader !== void 0;
+    if (entry.reader) await session.release(entry.reader);
+    entry.reader = candidate;
+    entry.identity = stat;
+    entry.offset = 0;
+    if (!initial) {
+      const message2 = replaced ? "has been replaced; following new file" : entry.error === "ENOENT" ? "has appeared; following new file" : "has become accessible";
+      await diagnostic(context, new Error(`'${entry.name}' ${message2}`));
+    }
+    entry.error = void 0;
+    return stat;
+  };
+  try {
+    for (const entry of entries) {
+      if (entry.name === "-") {
+        await header(entry);
+        await select(context, session.input(selection.idleMs));
+        continue;
+      }
+      const stat = await acquire(entry, true);
+      if (!stat) {
+        if (entry.error === "EISDIR" && selection.positive && !selection.bytes) break;
+        continue;
+      }
+      await header(entry);
+      if (!selection.positive && selection.count === 0) entry.offset = stat.size;
+      else {
+        if (selection.bytes && !selection.positive) entry.offset = Math.max(0, stat.size - selection.count);
+        const source = (async function* () {
+          while (entry.offset < stat.size) {
+            let chunk;
+            try {
+              chunk = await session.read(entry.reader, entry.offset, stat.size);
+            } catch (reason) {
+              throw new FollowReadError(reason);
+            }
+            if (!chunk.byteLength) break;
+            yield chunk;
+            entry.offset += chunk.byteLength;
+            await yieldTurn(caller.signal);
+          }
+        })();
+        try {
+          await select(context, source);
+        } catch (reason) {
+          if (!(reason instanceof FollowReadError)) throw reason;
+          await failure(entry, reason.reason, true);
+        }
+        if (selection.bytes && selection.positive) entry.offset = Math.max(entry.offset, selection.count - 1);
+      }
+    }
+    acknowledged = scheduler.now();
+    if (selection.idleMs !== 0 && !(selection.positive && !selection.bytes && entries.some((entry) => entry.error === "EISDIR"))) {
+      while (entries.some((entry) => entry.active)) {
+        session.assertOpen();
+        if (selection.idleMs !== void 0 && scheduler.now() - acknowledged >= selection.idleMs) break;
+        const round = [];
+        for (const entry of entries) {
+          if (!entry.active) continue;
+          let stat;
+          if (selection.mode === "F") stat = await acquire(entry, false);
+          else {
+            try {
+              stat = await session.stat(entry.reader);
+            } catch (reason) {
+              await failure(entry, reason, false);
+            }
+          }
+          if (!stat) continue;
+          if (stat.size < entry.offset) {
+            await diagnostic(context, new Error(`${entry.name}: file truncated`));
+            entry.offset = 0;
+          }
+          if (stat.size > entry.offset) round.push({ entry, end: stat.size });
+        }
+        let progressed = false;
+        while (round.some((item) => item.entry.reader && item.entry.offset < item.end)) {
+          for (const item of round) {
+            const { entry } = item;
+            if (!entry.reader || entry.offset >= item.end) continue;
+            let chunk;
+            try {
+              chunk = await session.read(entry.reader, entry.offset, item.end);
+            } catch (reason) {
+              await failure(entry, reason, false);
+              item.end = entry.offset;
+              continue;
+            }
+            if (!chunk.byteLength) {
+              item.end = entry.offset;
+              continue;
+            }
+            await header(entry);
+            await output(context, chunk);
+            entry.offset += chunk.byteLength;
+            acknowledged = scheduler.now();
+            progressed = true;
+            await yieldTurn(caller.signal);
+          }
+        }
+        await yieldTurn(caller.signal);
+        if (!progressed && entries.some((entry) => entry.active)) {
+          const remaining = selection.idleMs === void 0 ? 100 : Math.min(100, selection.idleMs - (scheduler.now() - acknowledged));
+          if (remaining <= 0) break;
+          await session.wait(void 0, remaining);
+        }
+      }
+    }
+  } catch (reason) {
+    primary = { reason };
+  } finally {
+    try {
+      await session.operation.close();
+    } catch (reason) {
+      primary ??= { reason };
+    }
+  }
+  caller.signal.throwIfAborted();
+  if (primary) {
+    if (session.operation.signal.aborted && session.operation.signal.reason instanceof FsError && session.operation.signal.reason.code === "EPIPE") return { exitCode: 141 };
+    throw primary.reason;
+  }
+  return { exitCode };
+}
+
 // packages/safe-bash/src/commands/streams.ts
 var inspectedInputRequirements = inputRequirements.map((mode) => mode.id === "file" ? { ...mode, capabilities: ["stat", "access"] } : mode);
 var countRequirements = [
@@ -4500,10 +4928,11 @@ function wcUtf8(consume) {
 function wcSpace(point, posix) {
   return point === 32 || point >= 9 && point <= 13 || point === 160 || point === 5760 || point >= 8192 && point <= 8202 || point === 8232 || point === 8233 || point === 8239 || point === 8287 || point === 12288 || !posix && point === 8288;
 }
-function headTail(name2) {
+function headTail(name2, maxTailFollowHandles = 64) {
   return define(name2, async (context) => {
     const args = context.args[0] && /^-[0-9]+$/u.test(context.args[0]) ? ["-n", context.args[0].slice(1), ...context.args.slice(1)] : context.args;
-    const parsed = options(args, "n:c:qv", { lines: "n", bytes: "c", quiet: "q", silent: "q", verbose: "v" });
+    const follow = name2 === "tail" ? parseTailFollow(args) : void 0;
+    const parsed = options(follow?.args ?? args, "n:c:qv", { lines: "n", bytes: "c", quiet: "q", silent: "q", verbose: "v" });
     if (parsed.flags.has("n") && parsed.flags.has("c")) throw new UsageError("cannot combine line and byte counts");
     const bytes2 = parsed.flags.has("c");
     const amount = value(parsed, bytes2 ? "c" : "n") ?? "10";
@@ -4511,6 +4940,15 @@ function headTail(name2) {
     const negative = amount.startsWith("-");
     const count2 = integer(amount.replace(/^[+-]/u, ""));
     const names = parsed.operands.length ? parsed.operands : ["-"];
+    if (follow?.mode) return followTail(context, {
+      names,
+      mode: follow.mode,
+      idleMs: follow.idleMs,
+      count: count2,
+      bytes: bytes2,
+      positive,
+      headers: parsed.flags.has("v") || names.length > 1 && !parsed.flags.has("q")
+    }, maxTailFollowHandles, (target, source) => positive ? prefix(target, source, Math.max(0, count2 - 1), bytes2, true) : suffix(target, source, count2, bytes2, false));
     await assertInputRequirements(context, names);
     assertCommandRequirements(context, inspectedInputRequirements, [names.some((name3) => name3 !== "-") ? "file" : "stdin"]);
     let exitCode = 0;
@@ -4590,10 +5028,13 @@ function characterSet(specification) {
   }
   return result;
 }
-function streamCommands(maxTeeTargets = 64) {
+function streamCommands(maxTeeTargets = 64, maxTailFollowHandles = 64) {
   if (!Number.isSafeInteger(maxTeeTargets) || maxTeeTargets < 0) {
     throw new RangeError("maxTeeTargets must be a nonnegative safe integer");
   }
+  if (!Number.isSafeInteger(maxTailFollowHandles) || maxTailFollowHandles < 0) {
+    throw new RangeError("maxTailFollowHandles must be a nonnegative safe integer");
+  }
   return [
     define("cat", async (context) => {
       const parsed = options(context.args, "nbsvETAute", { number: "n", "number-nonblank": "b", "squeeze-blank": "s", "show-ends": "E", "show-tabs": "T", "show-nonprinting": "v", "show-all": "A" });
@@ -4670,7 +5111,7 @@ function streamCommands(maxTeeTargets = 64) {
       }
     }),
     headTail("head"),
-    headTail("tail"),
+    headTail("tail", maxTailFollowHandles),
     define("wc", async (context) => {
       const parsed = options(context.args, "lwcm", { lines: "l", words: "w", bytes: "c", chars: "m" });
       if (!parsed.flags.size) for (const flag of ["l", "w", "c"]) parsed.flags.add(flag);
@@ -12101,7 +12542,9 @@ var Runtime = class _Runtime {
     this.cancellationDepth = cancellationDepth;
     this.cancellationMaxDepth = cancellationMaxDepth;
     this.outcomeFrame = outcomeFrame;
-    registerYieldCheckpoint(this.signal, () => this.budget.cpuCheckpoint());
+    const checkpoint = () => budget.cpuCheckpoint();
+    registerYieldCheckpoint(signal, checkpoint);
+    registerYieldCheckpoint(commandSignal, checkpoint);
   }
   fs;
   commands;
@@ -16551,7 +16994,6 @@ var InputCursor = class {
   #iterator;
   remainder;
   #read;
-  #readSettled = false;
   #readFailed = false;
   #turn = Promise.resolve();
   #returned;
@@ -16585,17 +17027,11 @@ var InputCursor = class {
     }
     if (this.#ended || this.#closed) return { value: void 0, done: true };
     if (!this.#read) {
-      this.#readSettled = false;
       this.#read = Promise.resolve().then(() => this.#closed ? { value: void 0, done: true } : this.#iterator.next()).then((result) => {
         if (result.done) return { value: void 0, done: true };
         if (!(result.value instanceof Uint8Array)) throw new TypeError("Shell stdin must yield Uint8Array");
         return { value: new Uint8Array(result.value), done: false };
       });
-      void this.#read.then(() => {
-        this.#readSettled = true;
-      }, () => {
-        this.#readSettled = true;
-      });
     }
     try {
       const result = await interruptible(this.#read, signal);
@@ -16619,15 +17055,12 @@ var InputCursor = class {
     }
     this.#closed = true;
     this.remainder = void 0;
-    const pendingRead = this.#read !== void 0 && !this.#readSettled;
     this.#returned ??= Promise.resolve().then(() => this.#iterator.return?.()).then(() => void 0);
     void this.#returned.catch(() => void 0);
-    if (!pendingRead) {
-      try {
-        await interruptible(this.#returned, signal);
-      } catch (error) {
-        if (!this.#readFailed) throw error;
-      }
+    try {
+      await interruptible(this.#returned, signal);
+    } catch (error) {
+      if (!this.#readFailed) throw error;
     }
     signal.throwIfAborted();
   }
@@ -20884,7 +21317,7 @@ function createBrowserCommands(options3 = {}) {
     ...basicCommands(),
     ...filesystemCommands(options3.maxDirectoryEntries),
     ...predicateCommands(),
-    ...streamCommands(options3.maxTeeTargets),
+    ...streamCommands(options3.maxTeeTargets, options3.maxTailFollowHandles),
     ...textCommands()
   ];
   if (options3.execution !== void 0) commands.push(...executionCommands(directExecutor(async (context) => {