@poe-platform/safe-bash 0.1.799 → 0.1.801

package/dist/safe-bash/command-chunks/{chunk-OLQG7ZCN.js → chunk-PEF7K3UQ.js}

@@ -1,6 +1,6 @@
 import {
   SearchError
-} from "./chunk-J4PEQWSF.js";
+} from "./chunk-VGG2DL5Q.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";
@@ -127,11 +127,13 @@ function escapeEreLiteral(ch) {
   if ("\\.^$*+?()[]{}|".includes(ch)) return `\\${ch}`;
   return ch;
 }
-function parsePattern(pattern, bre, insensitive, multiline, dotall, nullData) {
+function parsePattern(pattern, bre, insensitive, multiline, dotall, nullData, captures = false, captureOffset = 0) {
   let pos = 0;
   let needsVm = false;
   let hasCrossLinePotential = dotall;
   let hasUppercaseLiteral = false;
+  let captureCount = captureOffset;
+  const captureNames = /* @__PURE__ */ new Map();
   if (!multiline && pattern.includes("\n")) {
     throw new SearchError("unsupported ERE literal newline without --multiline (-U)");
   }
@@ -305,23 +307,36 @@ function parsePattern(pattern, bre, insensitive, multiline, dotall, nullData) {
         atomEre = br.ere;
       } else if (!bre && ch === "(") {
         pos++;
+        let capturing = true;
+        let name;
         if (pattern[pos] === "?") {
           pos++;
           if (pattern[pos] === ":") {
             pos++;
+            capturing = false;
           } else if (pattern[pos] === "=" || pattern[pos] === "!" || pattern[pos] === "<" && (pattern[pos + 1] === "=" || pattern[pos + 1] === "!")) {
             throw new SearchError("unsupported ERE lookaround");
+          } else if (pattern[pos] === "<" || pattern.startsWith("P<", pos)) {
+            pos += pattern[pos] === "<" ? 1 : 2;
+            const end = pattern.indexOf(">", pos);
+            name = pattern.slice(pos, end);
+            if (end < 0 || !/^[\p{L}_][\p{L}\p{N}_.[\]]*$/u.test(name) || captureNames.has(name)) {
+              throw new SearchError("invalid ERE capture name");
+            }
+            pos = end + 1;
           } else {
             throw new SearchError("unsupported ERE group syntax");
           }
         }
+        const index = capturing ? ++captureCount : 0;
+        if (name !== void 0) captureNames.set(name, index);
         const inner = parseAlternation(true);
         if (pos >= pattern.length || pattern[pos] !== ")") {
           throw new SearchError("invalid ERE: unclosed '('");
         }
         pos++;
         if (inner.node.type === "empty") needsVm = true;
-        atomNode = inner.node;
+        atomNode = captures && capturing ? { type: "capture", child: inner.node, index } : inner.node;
         atomEre = `(${inner.ere})`;
       } else if (!bre && (ch === "*" || ch === "+" || ch === "?" || ch === "{")) {
         throw new SearchError(`invalid ERE: unexpected quantifier '${ch}'`);
@@ -509,7 +524,9 @@ function parsePattern(pattern, bre, insensitive, multiline, dotall, nullData) {
     translatedEre: parsed.ere,
     needsVm,
     hasCrossLinePotential,
-    hasUppercaseLiteral
+    hasUppercaseLiteral,
+    captureCount,
+    captureNames
   };
 }
 function compileAstToNfa(root) {
@@ -531,6 +548,10 @@ function compileAstToNfa(root) {
         return emit({ op: "class", node, out: next });
       case "assert":
         return emit({ op: "assert", kind: node.kind, out: next });
+      case "capture": {
+        const end = emit({ op: "save", slot: node.index * 2 + 1, out: next });
+        return emit({ op: "save", slot: node.index * 2, out: build(node.child, end) });
+      }
       case "seq": {
         let cur = next;
         for (let i = node.children.length - 1; i >= 0; i--) {
@@ -584,6 +605,9 @@ function compileAstToNfa(root) {
         case "split":
           reordered.push({ op: "split", out1: inst.out1 + 1, out2: inst.out2 + 1 });
           break;
+        case "save":
+          reordered.push({ op: "save", slot: inst.slot, out: inst.out + 1 });
+          break;
         case "assert":
           reordered.push({ op: "assert", kind: inst.kind, out: inst.out + 1 });
           break;
@@ -604,51 +628,33 @@ function compileAstToNfa(root) {
 }
 function decodeUtf8Subject(bytes) {
   const len = bytes.length;
-  let ascii = true;
-  for (let i2 = 0; i2 < len; i2++) {
-    if (bytes[i2] >= 128) {
-      ascii = false;
-      break;
-    }
-  }
-  if (ascii) {
-    const cps2 = new Int32Array(len);
-    const offsets2 = new Int32Array(len + 1);
-    for (let i2 = 0; i2 < len; i2++) {
-      cps2[i2] = bytes[i2];
-      offsets2[i2] = i2;
-    }
-    offsets2[len] = len;
-    return { cps: cps2, offsets: offsets2, length: len };
-  }
   const cps = new Int32Array(len);
-  const offsets = new Int32Array(len + 1);
-  let count = 0;
+  const widths = new Uint8Array(len);
+  cps.fill(-1);
+  widths.fill(1);
   let i = 0;
   while (i < len) {
-    offsets[count] = i;
     const b0 = bytes[i];
-    if (b0 < 128) {
-      cps[count++] = b0;
-      i++;
-    } else if ((b0 & 224) === 192 && i + 1 < len) {
-      cps[count++] = (b0 & 31) << 6 | bytes[i + 1] & 63;
-      i += 2;
-    } else if ((b0 & 240) === 224 && i + 2 < len) {
-      cps[count++] = (b0 & 15) << 12 | (bytes[i + 1] & 63) << 6 | bytes[i + 2] & 63;
-      i += 3;
-    } else if ((b0 & 248) === 240 && i + 3 < len) {
-      cps[count++] = (b0 & 7) << 18 | (bytes[i + 1] & 63) << 12 | (bytes[i + 2] & 63) << 6 | bytes[i + 3] & 63;
-      i += 4;
-    } else {
-      cps[count++] = b0;
+    const width = b0 < 128 ? 1 : b0 >= 194 && b0 <= 223 ? 2 : b0 >= 224 && b0 <= 239 ? 3 : b0 >= 240 && b0 <= 244 ? 4 : 0;
+    let valid = width !== 0 && i + width <= len;
+    for (let j = 1; valid && j < width; j++) {
+      const byte = bytes[i + j];
+      valid = byte >= 128 && byte <= 191 && !(j === 1 && (b0 === 224 && byte < 160 || b0 === 237 && byte >= 160 || b0 === 240 && byte < 144 || b0 === 244 && byte >= 144));
+    }
+    if (!valid) {
       i++;
+      continue;
     }
+    let cp = width === 1 ? b0 : b0 & 127 >> width;
+    for (let j = 1; j < width; j++) cp = cp << 6 | bytes[i + j] & 63;
+    cps[i] = cp;
+    widths[i] = width;
+    i += width;
   }
-  offsets[count] = len;
-  return { cps, offsets, length: count };
+  return { cps, widths, length: len };
 }
 function extractLeadingLiteral(node) {
+  if (node.type === "capture") return extractLeadingLiteral(node.child);
   if (node.type === "literal") {
     return { cp: node.cp, insensitive: node.insensitive };
   }
@@ -664,16 +670,9 @@ function extractLeadingLiteral(node) {
   return void 0;
 }
 var ErgonomicVmMatcher = class {
-  insts;
-  multiline;
-  visited;
-  clistStates;
-  clistStarts;
-  nlistStates;
-  nlistStarts;
-  leadingLiteral;
-  stepStamp = 1;
-  constructor(rootAst, multiline) {
+  constructor(rootAst, multiline, captureCount = 0, captureNames = /* @__PURE__ */ new Map()) {
+    this.captureCount = captureCount;
+    this.captureNames = captureNames;
     this.insts = compileAstToNfa(rootAst);
     this.multiline = multiline;
     const n = this.insts.length;
@@ -682,9 +681,24 @@ var ErgonomicVmMatcher = class {
     this.clistStarts = new Int32Array(n);
     this.nlistStates = new Int32Array(n);
     this.nlistStarts = new Int32Array(n);
+    this.clistPositions = new Int32Array(n);
+    this.nlistPositions = new Int32Array(n);
     const lead = extractLeadingLiteral(rootAst);
     this.leadingLiteral = lead ? { cp: lead.cp, foldedCp: foldAsciiCp(lead.cp), insensitive: lead.insensitive } : void 0;
   }
+  captureCount;
+  captureNames;
+  insts;
+  multiline;
+  visited;
+  clistStates;
+  clistStarts;
+  nlistStates;
+  nlistStarts;
+  clistPositions;
+  nlistPositions;
+  leadingLiteral;
+  stepStamp = 1;
   evalAssertion(kind, cps, len, pos) {
     switch (kind) {
       case "bol":
@@ -713,50 +727,60 @@ var ErgonomicVmMatcher = class {
       }
     }
   }
-  findNext(subject, fromCp, minEndIfAtFrom) {
-    const { cps, length } = subject;
+  findNext(subject, from) {
+    const { cps, widths, length } = subject;
     const insts = this.insts;
     const visited = this.visited;
     const clistStates = this.clistStates;
     const clistStarts = this.clistStarts;
     const nlistStates = this.nlistStates;
     const nlistStarts = this.nlistStarts;
+    const clistPositions = this.clistPositions;
+    const nlistPositions = this.nlistPositions;
     let clistLen = 0;
     let nlistLen = 0;
     const lead = this.leadingLiteral;
     let matchedStart = -1;
     let matchedEnd = -1;
-    const addThread = (stateId, startPos, pos, stamp) => {
+    let matchedSlots;
+    const clistSlots = [];
+    const nlistSlots = [];
+    const addThread = (stateId, startPos, pos, stamp, slots) => {
       if (visited[stateId] === stamp) return false;
       visited[stateId] = stamp;
       const inst = insts[stateId];
       if (inst.op === "jump") {
-        return addThread(inst.out, startPos, pos, stamp);
+        return addThread(inst.out, startPos, pos, stamp, slots);
       }
       if (inst.op === "split") {
-        if (addThread(inst.out1, startPos, pos, stamp)) return true;
-        return addThread(inst.out2, startPos, pos, stamp);
+        if (addThread(inst.out1, startPos, pos, stamp, slots)) return true;
+        return addThread(inst.out2, startPos, pos, stamp, slots);
+      }
+      if (inst.op === "save") {
+        const saved = slots ? [...slots] : [];
+        saved[inst.slot] = pos;
+        return addThread(inst.out, startPos, pos, stamp, saved);
       }
       if (inst.op === "assert") {
         if (this.evalAssertion(inst.kind, cps, length, pos)) {
-          return addThread(inst.out, startPos, pos, stamp);
+          return addThread(inst.out, startPos, pos, stamp, slots);
         }
         return false;
       }
       if (inst.op === "accept") {
-        if (startPos === fromCp && pos < minEndIfAtFrom) {
-          return false;
-        }
         matchedStart = startPos;
         matchedEnd = pos;
+        matchedSlots = slots;
         return true;
       }
       nlistStates[nlistLen] = stateId;
       nlistStarts[nlistLen] = startPos;
+      nlistPositions[nlistLen] = pos;
+      if (this.captureCount) nlistSlots[nlistLen] = slots;
       nlistLen++;
       return false;
     };
-    for (let pos = fromCp; pos <= length; pos++) {
+    for (let pos = from; pos <= length; pos++) {
       if (clistLen === 0 && matchedStart < 0 && lead !== void 0 && pos < length) {
         if (!lead.insensitive) {
           while (pos < length && cps[pos] !== lead.cp) pos++;
@@ -773,7 +797,15 @@ var ErgonomicVmMatcher = class {
       nlistLen = 0;
       let acceptedAtPos = false;
       for (let i = 0; i < clistLen; i++) {
-        if (addThread(clistStates[i], clistStarts[i], pos, stamp)) {
+        if (clistPositions[i] > pos) {
+          nlistStates[nlistLen] = clistStates[i];
+          nlistStarts[nlistLen] = clistStarts[i];
+          nlistPositions[nlistLen] = clistPositions[i];
+          if (this.captureCount) nlistSlots[nlistLen] = clistSlots[i];
+          nlistLen++;
+          continue;
+        }
+        if (addThread(clistStates[i], clistStarts[i], pos, stamp, clistSlots[i])) {
           acceptedAtPos = true;
           break;
         }
@@ -782,7 +814,7 @@ var ErgonomicVmMatcher = class {
         addThread(0, pos, pos, stamp);
       }
       if (matchedStart >= 0 && nlistLen === 0) {
-        return { start: matchedStart, end: matchedEnd };
+        return { start: matchedStart, end: matchedEnd, slots: matchedSlots };
       }
       if (pos === length) break;
       const cp = cps[pos];
@@ -792,7 +824,12 @@ var ErgonomicVmMatcher = class {
         const startPos = nlistStarts[i];
         const inst = insts[st];
         let nextOut = -1;
-        if (inst.op === "literal") {
+        const pendingPosition = nlistPositions[i];
+        if (pendingPosition > pos) {
+          nextOut = st;
+        } else if (cp < 0) {
+          continue;
+        } else if (inst.op === "literal") {
           if (inst.insensitive ? foldAsciiCp(cp) === foldAsciiCp(inst.cp) : cp === inst.cp) nextOut = inst.out;
         } else if (inst.op === "dot") {
           if ((inst.dotall || cp !== 10) && (inst.nullData || cp !== 0)) nextOut = inst.out;
@@ -802,14 +839,16 @@ var ErgonomicVmMatcher = class {
         if (nextOut >= 0) {
           clistStates[clistLen] = nextOut;
           clistStarts[clistLen] = startPos;
+          clistPositions[clistLen] = pendingPosition > pos ? pendingPosition : pos + widths[pos];
+          if (this.captureCount) clistSlots[clistLen] = nlistSlots[i];
           clistLen++;
         }
       }
       if (matchedStart >= 0 && clistLen === 0) {
-        return { start: matchedStart, end: matchedEnd };
+        return { start: matchedStart, end: matchedEnd, slots: matchedSlots };
       }
     }
-    return matchedStart >= 0 ? { start: matchedStart, end: matchedEnd } : void 0;
+    return matchedStart >= 0 ? { start: matchedStart, end: matchedEnd, slots: matchedSlots } : void 0;
   }
   matchBytes(bytes, all) {
     const subject = decodeUtf8Subject(bytes);
@@ -817,12 +856,27 @@ var ErgonomicVmMatcher = class {
     let cursor = 0;
     let prevEnd = -1;
     while (cursor <= subject.length) {
-      const minEnd = cursor === prevEnd ? cursor + 1 : cursor;
-      const found = this.findNext(subject, cursor, minEnd);
+      const found = this.findNext(subject, cursor);
       if (!found) break;
+      if (found.start === found.end && found.start === prevEnd) {
+        cursor = found.end + 1;
+        continue;
+      }
+      const captures = this.captureCount ? /* @__PURE__ */ new Map() : void 0;
+      if (found.slots && captures) {
+        for (let index = 1; index <= this.captureCount; index++) {
+          const start = found.slots[index * 2], end = found.slots[index * 2 + 1];
+          if (start !== void 0 && end !== void 0) captures.set(index, { start, end });
+        }
+        for (const [name, index] of this.captureNames) {
+          const span = captures.get(index);
+          if (span) captures.set(name, span);
+        }
+      }
       matches.push({
-        start: subject.offsets[found.start],
-        end: subject.offsets[found.end]
+        start: found.start,
+        end: found.end,
+        ...captures ? { captures } : {}
       });
       if (!all) break;
       prevEnd = found.end;
@@ -853,7 +907,7 @@ function buildFixedAst(pattern, insensitive) {
 var preparedRegexCache = /* @__PURE__ */ new Map();
 var MAX_PREPARED_REGEX_CACHE = 256;
 function prepareErgonomicRegex(patterns, config) {
-  const cacheKey = `${config.kind}\0${config.extended ? 1 : 0}\0${config.fixed ? 1 : 0}\0${config.caseMode}\0${config.multiline ? 1 : 0}\0${config.multilineDotall ? 1 : 0}\0${config.word ? 1 : 0}\0${config.whole ? 1 : 0}\0${config.nullData ? 1 : 0}\0${patterns.join("
")}`;
+  const cacheKey = JSON.stringify([config, patterns]);
   const cached = preparedRegexCache.get(cacheKey);
   if (cached !== void 0) return cached;
   const multiline = Boolean(config.multiline);
@@ -882,13 +936,20 @@ function prepareErgonomicRegex(patterns, config) {
   }
   const translated = [];
   const branches = [];
-  let anyNeedsVm = false;
+  let anyNeedsVm = config.captures ?? false;
   let anyCrossLine = false;
+  let captureCount = 0;
+  const captureNames = /* @__PURE__ */ new Map();
   for (const pat of patterns) {
     const provisionalInsensitive = config.caseMode === "insensitive";
-    const firstParse = parsePattern(pat, bre, provisionalInsensitive, multiline, dotall, config.nullData);
+    const firstParse = parsePattern(pat, bre, provisionalInsensitive, multiline, dotall, config.nullData, config.captures, captureCount);
     const effectiveInsensitive = config.caseMode === "insensitive" || config.caseMode === "smart" && !firstParse.hasUppercaseLiteral;
-    const outcome = effectiveInsensitive !== provisionalInsensitive ? parsePattern(pat, bre, effectiveInsensitive, multiline, dotall, config.nullData) : firstParse;
+    const outcome = effectiveInsensitive !== provisionalInsensitive ? parsePattern(pat, bre, effectiveInsensitive, multiline, dotall, config.nullData, config.captures, captureCount) : firstParse;
+    captureCount = outcome.captureCount;
+    for (const [name, index] of outcome.captureNames) {
+      if (captureNames.has(name)) throw new SearchError("invalid ERE duplicate capture name");
+      captureNames.set(name, index);
+    }
     translated.push(outcome.translatedEre);
     branches.push(outcome.ast);
     if (outcome.needsVm) anyNeedsVm = true;
@@ -910,7 +971,7 @@ function prepareErgonomicRegex(patterns, config) {
     }
     result = {
       mode: "vm",
-      vm: new ErgonomicVmMatcher(root, multiline),
+      vm: new ErgonomicVmMatcher(root, multiline, config.captures ? captureCount : 0, captureNames),
       crossLine: multiline && anyCrossLine
     };
   }

package/dist/safe-bash/command-chunks/chunk-PII4YEZW.js

@@ -0,0 +1,123 @@
+import {
+  crcTable
+} from "./chunk-H622NS6Z.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-zip-engine/src/zip/crypto.ts
+init_buffer();
+import { readBytes } from "../../safe-bash-contracts/index.js";
+import { PublicDiagnostic } from "../../safe-bash-contracts/diagnostics.js";
+import { yieldTurn } from "../../safe-bash-contracts/yield.js";
+import { fail } from "../../safe-bash-io-engine/commands/archive/internal.js";
+var ZipHostFailure = class extends PublicDiagnostic {
+  constructor(code) {
+    super({
+      "no-echo": "ZIP no-echo password capability is unavailable",
+      entropy: "ZIP entropy capability is unavailable",
+      "entropy-failed": "ZIP entropy capability failed",
+      "entropy-bytes": "ZIP entropy capability must return 11 bytes",
+      "prompt-failed": "ZIP password capability failed",
+      "prompt-eof": "ZIP EOF while reading password",
+      "password-bytes": "ZIP invalid password bytes",
+      "password-empty": "zero length password not allowed",
+      "password-confirm": "password verification failed"
+    }[code]);
+    this.code = code;
+  }
+  code;
+};
+async function* encryptZipPayload(source, encryption, verifier, signal) {
+  signal.throwIfAborted();
+  const password = new Uint8Array(encryption.password);
+  let random;
+  try {
+    random = await encryption.entropy(11, signal);
+  } catch (error) {
+    signal.throwIfAborted();
+    throw new ZipHostFailure(error instanceof ZipHostFailure && error.code === "entropy" ? "entropy" : "entropy-failed");
+  }
+  signal.throwIfAborted();
+  if (!(random instanceof Uint8Array) || random.length !== 11) throw new ZipHostFailure("entropy-bytes");
+  const header = new Uint8Array(12);
+  header.set(random);
+  header[11] = verifier;
+  yield* zipCrypto((async function* () {
+    yield header;
+    yield* readBytes(source, signal);
+  })(), password, false, signal);
+}
+async function* decryptZipPayload(source, password, verifier, signal) {
+  let header = 0;
+  for await (const chunk of zipCrypto(source, new Uint8Array(password), true, signal)) {
+    let offset = 0;
+    while (header < 12 && offset < chunk.length) {
+      if (header === 11 && chunk[offset] !== verifier) fail("ZIP incorrect password");
+      header++;
+      offset++;
+    }
+    if (offset < chunk.length) yield chunk.subarray(offset);
+  }
+  if (header !== 12) fail("ZIP truncated encryption header");
+}
+async function readZipPassword(host, maxBytes, signal, confirm) {
+  if (!host?.password) throw new ZipHostFailure("no-echo");
+  const read = async (prompt) => {
+    signal.throwIfAborted();
+    let bytes;
+    try {
+      bytes = await host.password({ prompt, maxBytes, signal });
+    } catch {
+      signal.throwIfAborted();
+      throw new ZipHostFailure("prompt-failed");
+    }
+    signal.throwIfAborted();
+    if (!bytes) throw new ZipHostFailure("prompt-eof");
+    if (!(bytes instanceof Uint8Array) || bytes.length > maxBytes || bytes.includes(0)) throw new ZipHostFailure("password-bytes");
+    return new Uint8Array(bytes);
+  };
+  const password = await read("Enter password: ");
+  if (confirm) {
+    if (!password.length) throw new ZipHostFailure("password-empty");
+    const repeated = await read("Verify password: ");
+    if (password.length !== repeated.length || password.some((byte, index) => byte !== repeated[index])) throw new ZipHostFailure("password-confirm");
+  }
+  return password;
+}
+async function* zipCrypto(source, password, decode, signal) {
+  signal.throwIfAborted();
+  let key0 = 305419896, key1 = 591751049, key2 = 878082192;
+  const update = (byte) => {
+    key0 = (key0 >>> 8 ^ crcTable[(key0 ^ byte) & 255]) >>> 0;
+    key1 = Math.imul(key1 + (key0 & 255), 134775813) + 1 >>> 0;
+    key2 = (key2 >>> 8 ^ crcTable[(key2 ^ key1 >>> 24) & 255]) >>> 0;
+  };
+  for (let index = 0; index < password.length; index++) {
+    update(password[index]);
+    if ((index + 1) % 65536 === 0) await yieldTurn(signal);
+  }
+  for await (const bytes of readBytes(source, signal)) {
+    for (let offset = 0; offset < bytes.length; offset += 65536) {
+      signal.throwIfAborted();
+      const output = new Uint8Array(Math.min(65536, bytes.length - offset));
+      for (let index = 0; index < output.length; index++) {
+        const value = bytes[offset + index];
+        const temporary = key2 & 65535 | 2;
+        const transformed = value ^ Math.imul(temporary, temporary ^ 1) >>> 8 & 255;
+        update(decode ? transformed : value);
+        output[index] = transformed;
+      }
+      yield output;
+      await yieldTurn(signal);
+    }
+  }
+}
+
+export {
+  ZipHostFailure,
+  encryptZipPayload,
+  decryptZipPayload,
+  readZipPassword,
+  zipCrypto
+};

package/dist/safe-bash/command-chunks/{chunk-AIRGA2SU.js → chunk-PMBFZXTK.js}

@@ -2,7 +2,7 @@ import {
   createXlsxWriter,
   probeXlsx,
   readXlsx
-} from "./chunk-6BETHLXZ.js";
+} from "./chunk-DZCY63VJ.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/{chunk-ZT4KSS2V.js → chunk-PTT3I223.js}

@@ -1,6 +1,6 @@
 import {
   truth
-} from "./chunk-VVI4Z73I.js";
+} from "./chunk-QP4R6GLA.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/{chunk-4Y3WVMK4.js → chunk-PV66YWHB.js}

@@ -64,6 +64,7 @@ var Budget = class {
   add(kind, amount = 1) {
     const maximum = kind === "input" ? this.limits.maxInputBytes : kind === "tokens" ? this.limits.maxTokens : kind === "nodes" ? this.limits.maxNodes : this.limits.maxTableCells;
     this.check(amount, maximum - this[kind], kind);
+    if (kind === "input") this.context.inputBudget?.check(this.input + amount);
     this[kind] += amount;
   }
   async emit(text) {