@poe-platform/safe-bash 0.1.802 → 0.1.804

package/dist/safe-bash-calendar-engine/time-env/format.js

@@ -4,7 +4,7 @@ import {
   nanosecondsPerSecond,
   utcMilliseconds,
   weekdayNames
-} from "../../safe-bash/command-chunks/chunk-PXEIT2O4.js";
+} from "../../safe-bash/command-chunks/chunk-6UR7V3ET.js";
 import {
   CommandFailure,
   checkSize

package/dist/safe-bash-command-alias/index.d.ts

@@ -0,0 +1,13 @@
+import { type CommandDefinition, type VirtualShellPlugin } from "../safe-bash-contracts/index.js";
+export interface AliasLimits {
+    readonly maxArgumentBytes: number;
+    readonly maxAliasBytes: number;
+}
+export interface AliasCommandsOptions {
+    readonly aliases?: Map<string, string>;
+    readonly limits?: Partial<AliasLimits>;
+    readonly replace?: boolean;
+}
+export declare function createAliasCommand(options?: AliasCommandsOptions): CommandDefinition;
+export declare function createAliasCommands(options?: AliasCommandsOptions): CommandDefinition[];
+export declare function aliasCommands(options?: AliasCommandsOptions): VirtualShellPlugin;

package/dist/safe-bash-command-alias/index.js

@@ -0,0 +1,88 @@
+import {
+  init_buffer
+} from "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-alias/src/index.ts
+init_buffer();
+import { writeText } from "../safe-bash-contracts/index.js";
+function createAliasCommand(options = {}) {
+  const aliases = options.aliases ?? /* @__PURE__ */ new Map();
+  const limits = { maxArgumentBytes: 1024 * 1024, maxAliasBytes: 1024 * 1024, ...options.limits };
+  for (const value of Object.values(limits)) if (value !== Infinity && (!Number.isSafeInteger(value) || value < 0)) throw new RangeError("Invalid alias limit");
+  return { name: "alias", async execute(context) {
+    const encoder = new TextEncoder();
+    let argumentBytes = 0;
+    for (const arg of context.args) {
+      context.signal.throwIfAborted();
+      argumentBytes += encoder.encode(arg).length;
+      if (argumentBytes > limits.maxArgumentBytes) throw new RangeError("alias argument limit exceeded");
+    }
+    let index = 0;
+    let print = false;
+    for (; index < context.args.length; index++) {
+      const arg = context.args[index];
+      if (arg === "--") {
+        index++;
+        break;
+      }
+      if (!arg.startsWith("-") || arg === "-") break;
+      if ([...arg.slice(1)].every((flag) => flag === "p")) print = true;
+      else {
+        await writeText(context.stderr, `alias: ${arg}: invalid option
+`);
+        return { exitCode: 2 };
+      }
+    }
+    const emit = async (name) => {
+      await writeText(context.stdout, `alias ${name}='${aliases.get(name).split("'").join("'\\''")}'
+`);
+    };
+    if (print || index === context.args.length) for (const name of [...aliases.keys()].sort()) {
+      context.signal.throwIfAborted();
+      await emit(name);
+    }
+    let exitCode = 0;
+    for (const arg of context.args.slice(index)) {
+      context.signal.throwIfAborted();
+      const equal = arg.indexOf("=");
+      if (equal < 0) {
+        if (aliases.has(arg)) await emit(arg);
+        else {
+          await writeText(context.stderr, `alias: ${arg}: not found
+`);
+          exitCode = 1;
+        }
+        continue;
+      }
+      const name = arg.slice(0, equal);
+      if (!name || [...name].some((char) => " /$`=;|&()<>'\"\\	\r\n".includes(char))) {
+        await writeText(context.stderr, `alias: ${name}: invalid alias name
+`);
+        exitCode = 1;
+        continue;
+      }
+      const value = arg.slice(equal + 1);
+      let bytes = encoder.encode(name).length + encoder.encode(value).length;
+      for (const [key, existing] of aliases) if (key !== name) {
+        context.signal.throwIfAborted();
+        bytes += encoder.encode(key).length + encoder.encode(existing).length;
+      }
+      if (bytes > limits.maxAliasBytes) throw new RangeError("alias storage limit exceeded");
+      aliases.set(name, value);
+    }
+    return { exitCode };
+  } };
+}
+function createAliasCommands(options = {}) {
+  return [createAliasCommand(options)];
+}
+function aliasCommands(options = {}) {
+  return { name: "alias", setup(host) {
+    for (const command of createAliasCommands(options)) host.commands.register(command, { replace: options.replace ?? false });
+  } };
+}
+export {
+  aliasCommands,
+  createAliasCommand,
+  createAliasCommands
+};

package/dist/safe-bash-command-apply-patch/apply.js

@@ -1,8 +1,8 @@
 import {
   execute
-} from "../safe-bash/command-chunks/chunk-MIXBO6U7.js";
-import "../safe-bash/command-chunks/chunk-BDSMROQZ.js";
-import "../safe-bash/command-chunks/chunk-ALDC4XP4.js";
+} from "../safe-bash/command-chunks/chunk-PTZLF456.js";
+import "../safe-bash/command-chunks/chunk-36GFRF2N.js";
+import "../safe-bash/command-chunks/chunk-QILLRNES.js";
 import "../safe-bash/command-chunks/chunk-4PX2KMUK.js";
 import "../safe-bash/command-chunks/chunk-4HZISH3R.js";
 import "../safe-bash/command-chunks/chunk-HX3SHTCE.js";

package/dist/safe-bash-command-apply-patch/index.js

@@ -1,8 +1,8 @@
 import {
   execute
-} from "../safe-bash/command-chunks/chunk-MIXBO6U7.js";
-import "../safe-bash/command-chunks/chunk-BDSMROQZ.js";
-import "../safe-bash/command-chunks/chunk-ALDC4XP4.js";
+} from "../safe-bash/command-chunks/chunk-PTZLF456.js";
+import "../safe-bash/command-chunks/chunk-36GFRF2N.js";
+import "../safe-bash/command-chunks/chunk-QILLRNES.js";
 import "../safe-bash/command-chunks/chunk-4PX2KMUK.js";
 import {
   settings

package/dist/safe-bash-command-apply-patch/matcher.js

@@ -1,6 +1,6 @@
 import {
   contents
-} from "../safe-bash/command-chunks/chunk-ALDC4XP4.js";
+} from "../safe-bash/command-chunks/chunk-QILLRNES.js";
 import "../safe-bash/command-chunks/chunk-4PX2KMUK.js";
 import "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
 export {

package/dist/safe-bash-command-apply-patch/parser.js

@@ -1,7 +1,7 @@
 import {
   parse,
   targetPath
-} from "../safe-bash/command-chunks/chunk-BDSMROQZ.js";
+} from "../safe-bash/command-chunks/chunk-36GFRF2N.js";
 import "../safe-bash/command-chunks/chunk-4PX2KMUK.js";
 import "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
 export {

package/dist/safe-bash-command-awk/awk-pipes.js

@@ -1,7 +1,7 @@
 import {
   AwkPipes
-} from "../safe-bash/command-chunks/chunk-DB453IE6.js";
-import "../safe-bash/command-chunks/chunk-7K6JYKPJ.js";
+} from "../safe-bash/command-chunks/chunk-6FZQUOSJ.js";
+import "../safe-bash/command-chunks/chunk-6M2ELGEN.js";
 import "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
 export {
   AwkPipes

package/dist/safe-bash-command-awk/awk-reader.js

@@ -1,7 +1,7 @@
 import {
   Reader,
   clearAwkReaderPool
-} from "../safe-bash/command-chunks/chunk-7K6JYKPJ.js";
+} from "../safe-bash/command-chunks/chunk-6M2ELGEN.js";
 import "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
 export {
   Reader,

package/dist/safe-bash-command-awk/awk-runtime.js

@@ -1,10 +1,10 @@
 import {
   AwkRuntime
-} from "../safe-bash/command-chunks/chunk-RMWQAAO5.js";
+} from "../safe-bash/command-chunks/chunk-7IR4NRNE.js";
 import "../safe-bash/command-chunks/chunk-5BSTFCXG.js";
-import "../safe-bash/command-chunks/chunk-DB453IE6.js";
+import "../safe-bash/command-chunks/chunk-6FZQUOSJ.js";
 import "../safe-bash/command-chunks/chunk-6BNTBWIK.js";
-import "../safe-bash/command-chunks/chunk-7K6JYKPJ.js";
+import "../safe-bash/command-chunks/chunk-6M2ELGEN.js";
 import "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
 export {
   AwkRuntime

package/dist/safe-bash-command-awk/awk.js

@@ -1,15 +1,15 @@
 import {
   awkCommand
-} from "../safe-bash/command-chunks/chunk-P2N33UMN.js";
-import "../safe-bash/command-chunks/chunk-2H4JTFIL.js";
-import "../safe-bash/command-chunks/chunk-RMWQAAO5.js";
+} from "../safe-bash/command-chunks/chunk-5MIKM54M.js";
+import "../safe-bash/command-chunks/chunk-7IR4NRNE.js";
 import "../safe-bash/command-chunks/chunk-5BSTFCXG.js";
-import "../safe-bash/command-chunks/chunk-DB453IE6.js";
+import "../safe-bash/command-chunks/chunk-6FZQUOSJ.js";
 import "../safe-bash/command-chunks/chunk-XNLFHHOC.js";
 import "../safe-bash/command-chunks/chunk-6BNTBWIK.js";
 import "../safe-bash/command-chunks/chunk-KFVV7ZJO.js";
 import "../safe-bash/command-chunks/chunk-EQ4HV54N.js";
-import "../safe-bash/command-chunks/chunk-7K6JYKPJ.js";
+import "../safe-bash/command-chunks/chunk-6M2ELGEN.js";
+import "../safe-bash/command-chunks/chunk-2H4JTFIL.js";
 import "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
 export {
   awkCommand

package/dist/safe-bash-command-awk/index.js

@@ -1,15 +1,15 @@
 import {
   awkCommand
-} from "../safe-bash/command-chunks/chunk-P2N33UMN.js";
-import "../safe-bash/command-chunks/chunk-2H4JTFIL.js";
-import "../safe-bash/command-chunks/chunk-RMWQAAO5.js";
+} from "../safe-bash/command-chunks/chunk-5MIKM54M.js";
+import "../safe-bash/command-chunks/chunk-7IR4NRNE.js";
 import "../safe-bash/command-chunks/chunk-5BSTFCXG.js";
-import "../safe-bash/command-chunks/chunk-DB453IE6.js";
+import "../safe-bash/command-chunks/chunk-6FZQUOSJ.js";
 import "../safe-bash/command-chunks/chunk-XNLFHHOC.js";
 import "../safe-bash/command-chunks/chunk-6BNTBWIK.js";
 import "../safe-bash/command-chunks/chunk-KFVV7ZJO.js";
 import "../safe-bash/command-chunks/chunk-EQ4HV54N.js";
-import "../safe-bash/command-chunks/chunk-7K6JYKPJ.js";
+import "../safe-bash/command-chunks/chunk-6M2ELGEN.js";
+import "../safe-bash/command-chunks/chunk-2H4JTFIL.js";
 import {
   init_buffer
 } from "../safe-bash/command-chunks/chunk-HX3SHTCE.js";

package/dist/safe-bash-command-bc/index.js

@@ -4,7 +4,182 @@ import {
 
 // packages/safe-bash-command-bc/src/index.ts
 init_buffer();
-import { Decimal } from "decimal.js";
+
+// packages/safe-bash-command-bc/src/math.ts
+init_buffer();
+var abs = (x) => x < 0n ? -x : x;
+async function mathValue(name, args, scale, tick) {
+  if (!["s", "c", "a", "l", "e", "j"].includes(name)) return void 0;
+  const raw = args[name === "j" ? 1 : 0] ?? { coeff: 0n, scale: 0 };
+  const pending = tick();
+  if (pending) await pending;
+  if (name === "e" && raw.coeff < 0n && abs(raw.coeff) > BigInt(scale + 1) * 3n * 10n ** BigInt(raw.scale)) {
+    return { coeff: 0n, scale };
+  }
+  const integer = abs(raw.coeff) / 10n ** BigInt(raw.scale);
+  const extra = name === "e" || name === "j" ? Number(integer) + 1 : integer.toString().length;
+  const precision = scale + Math.max(extra, 3 * raw.scale) + 32;
+  for (let digits = 0; digits < precision; digits += 64) {
+    const pending2 = tick();
+    if (pending2) await pending2;
+  }
+  const unit = 10n ** BigInt(precision);
+  const mul = (a, b) => a * b / unit;
+  const div = (a, b) => a * unit / b;
+  const x = raw.coeff * unit / 10n ** BigInt(raw.scale);
+  if (name === "e" && raw.coeff < 0n && x === 0n) {
+    return { coeff: 10n ** BigInt(scale) - 1n, scale };
+  }
+  async function sqrt(value) {
+    const target = value * unit;
+    let guess = 1n << BigInt(Math.ceil(target.toString(2).length / 2));
+    while (true) {
+      const pending2 = tick();
+      if (pending2) await pending2;
+      const next = (guess + target / guess) / 2n;
+      if (next >= guess) return guess;
+      guess = next;
+    }
+  }
+  async function atan(value) {
+    const negative = value < 0n;
+    let reduced = abs(value);
+    const reciprocal = reduced > unit;
+    if (reciprocal) reduced = div(unit, reduced);
+    let doubles = 0;
+    while (reduced > unit / 4n) {
+      const pending2 = tick();
+      if (pending2) await pending2;
+      reduced = div(reduced, unit + await sqrt(unit + mul(reduced, reduced)));
+      doubles++;
+    }
+    const square = -mul(reduced, reduced);
+    let power = reduced;
+    let sum = reduced;
+    for (let k = 3n; power !== 0n; k += 2n) {
+      const pending2 = tick();
+      if (pending2) await pending2;
+      power = mul(power, square);
+      const term = power / k;
+      if (term === 0n) break;
+      sum += term;
+    }
+    sum *= 2n ** BigInt(doubles);
+    if (reciprocal) sum = await pi() / 2n - sum;
+    return negative ? -sum : sum;
+  }
+  async function pi() {
+    return 16n * await atan(unit / 5n) - 4n * await atan(unit / 239n);
+  }
+  async function logSeries(value) {
+    const z = div(value - unit, value + unit);
+    const square = mul(z, z);
+    let power = z;
+    let sum = z;
+    for (let k = 3n; power !== 0n; k += 2n) {
+      const pending2 = tick();
+      if (pending2) await pending2;
+      power = mul(power, square);
+      const term = power / k;
+      if (term === 0n) break;
+      sum += term;
+    }
+    return 2n * sum;
+  }
+  let result;
+  switch (name) {
+    case "a":
+      result = await atan(x);
+      break;
+    case "l": {
+      if (raw.coeff <= 0n) throw new Error("Runtime error: l(x) domain error");
+      let numerator = raw.coeff;
+      let denominator = 10n ** BigInt(raw.scale);
+      let shifts = 0n;
+      while (numerator >= 2n * denominator) {
+        const pending2 = tick();
+        if (pending2) await pending2;
+        denominator *= 2n;
+        shifts++;
+      }
+      while (numerator < denominator) {
+        const pending2 = tick();
+        if (pending2) await pending2;
+        numerator *= 2n;
+        shifts--;
+      }
+      result = await logSeries(numerator * unit / denominator);
+      if (shifts !== 0n) result += shifts * await logSeries(2n * unit);
+      break;
+    }
+    case "e": {
+      let reduced = abs(x);
+      let squares = 0;
+      while (reduced > unit / 2n) {
+        const pending2 = tick();
+        if (pending2) await pending2;
+        reduced /= 2n;
+        squares++;
+      }
+      let term = unit;
+      result = unit;
+      for (let k = 1n; term !== 0n; k++) {
+        const pending2 = tick();
+        if (pending2) await pending2;
+        term = mul(term, reduced) / k;
+        result += term;
+      }
+      for (let k = 0; k < squares; k++) {
+        const pending2 = tick();
+        if (pending2) await pending2;
+        result = mul(result, result);
+      }
+      if (x < 0n) result = div(unit, result);
+      break;
+    }
+    case "s":
+    case "c": {
+      const circle = 2n * await pi();
+      let reduced = x % circle;
+      if (reduced > circle / 2n) reduced -= circle;
+      if (reduced < -circle / 2n) reduced += circle;
+      const square = -mul(reduced, reduced);
+      let term = name === "s" ? reduced : unit;
+      result = term;
+      for (let k = name === "s" ? 2n : 1n; term !== 0n; k += 2n) {
+        const pending2 = tick();
+        if (pending2) await pending2;
+        term = mul(term, square) / (k * (k + 1n));
+        result += term;
+      }
+      break;
+    }
+    default: {
+      const orderValue = args[0] ?? { coeff: 0n, scale: 0 };
+      const n = orderValue.coeff / 10n ** BigInt(orderValue.scale);
+      const order = abs(n);
+      const half = x / 2n;
+      let term = unit;
+      for (let i = 1n; i <= order; i++) {
+        const pending2 = tick();
+        if (pending2) await pending2;
+        term = mul(term, half) / i;
+      }
+      result = term;
+      const factor = -mul(half, half);
+      for (let k = 1n; term !== 0n; k++) {
+        const pending2 = tick();
+        if (pending2) await pending2;
+        term = mul(term, factor) / (k * (order + k));
+        result += term;
+      }
+      if (n < 0n && order % 2n === 1n) result = -result;
+    }
+  }
+  return { coeff: result / 10n ** BigInt(precision - scale), scale };
+}
+
+// packages/safe-bash-command-bc/src/index.ts
 import {
   commandRuntimeIdentity,
   readBytes,
@@ -35,11 +210,12 @@ var UsageError = class extends Error {
     super(message);
   }
 };
-async function collectSourceBytes(source, signal, maxBytes) {
+async function collectSourceBytes(source, signal, maxBytes, admit) {
   const chunks = [];
   let total = 0;
   for await (const chunk of readBytes(source, signal)) {
     total += chunk.byteLength;
+    admit(chunk.byteLength);
     if (total > maxBytes) throw new Error(`input exceeds maximum size (${maxBytes} bytes)`);
     chunks.push(chunk);
   }
@@ -119,13 +295,20 @@ function modDec(a, b, currentScale) {
 function truncToInt(d) {
   return d.scale > 0 ? d.coeff / pow10(d.scale) : d.coeff;
 }
-function powDec(base, exp, currentScale, maxExponent) {
+async function powDec(base, exp, currentScale, maxExponent, tick) {
   let n = truncToInt(exp);
   if (n === 0n) return ONE;
   const neg = n < 0n;
   if (neg) n = -n;
   if (maxExponent !== Infinity && n > BigInt(maxExponent)) throw new Error(`exponent exceeds maximum limit (${maxExponent})`);
-  const coeff = base.coeff ** n;
+  let coeff = 1n;
+  let factor = base.coeff;
+  for (let remaining = n; remaining > 0n; remaining >>= 1n) {
+    const pending = tick();
+    if (pending) await pending;
+    if (remaining & 1n) coeff *= factor;
+    if (remaining > 1n) factor *= factor;
+  }
   const fullScale = BigInt(base.scale) * n;
   if (neg) {
     if (coeff === 0n) throw new Error("Runtime error (func=(main), adr=0): Divide by zero");
@@ -235,59 +418,6 @@ function formatDecimalInBase(val, obase) {
   }
   return (neg && absCoeff !== 0n ? "-" : "") + (intOut === "0" ? "" : intOut) + "." + fracOut;
 }
-async function mathValue(name, args, scale, tick) {
-  if (!["s", "c", "a", "l", "e", "j"].includes(name)) return void 0;
-  const decimal = (value) => `${value.coeff}e-${value.scale}`;
-  const raw = args[name === "j" ? 1 : 0] ?? ZERO;
-  const magnitude = new Decimal(decimal(raw)).abs();
-  const extra = name === "e" || name === "j" ? magnitude.ceil().toNumber() : Math.max(0, magnitude.e + 1);
-  const D = Decimal.clone({ precision: scale + extra + 32, rounding: Decimal.ROUND_DOWN });
-  const x = new D(decimal(raw));
-  let result;
-  switch (name) {
-    case "s":
-      result = x.sin();
-      break;
-    case "c":
-      result = x.cos();
-      break;
-    case "a":
-      result = x.atan();
-      break;
-    case "l":
-      if (x.lte(0)) throw new Error("Runtime error: l(x) domain error");
-      result = x.ln();
-      break;
-    case "e":
-      result = x.exp();
-      break;
-    default: {
-      const n = truncToInt(args[0] ?? ZERO);
-      const order = n < 0n ? -n : n;
-      const half = x.div(2);
-      let term = new D(1);
-      for (let i = 1n; i <= order; i++) {
-        const pending = tick();
-        if (pending) await pending;
-        term = term.mul(half).div(i.toString());
-      }
-      result = term;
-      const factor = half.mul(half).neg();
-      const epsilon = new D(10).pow(-scale - 16);
-      for (let k = 1n; !term.isZero(); k++) {
-        const pending = tick();
-        if (pending) await pending;
-        term = term.mul(factor).div((k * (order + k)).toString());
-        result = result.add(term);
-        if (term.abs().lt(epsilon) && new D((k * (order + k)).toString()).gt(factor.abs())) break;
-      }
-      if (n < 0n && order % 2n === 1n) result = result.neg();
-    }
-  }
-  if (!result.isFinite()) throw new Error("math domain/range error");
-  const fixed = result.toFixed(scale, Decimal.ROUND_DOWN);
-  return { coeff: BigInt(fixed.split(".").join("")), scale };
-}
 function tokenizeBc(source) {
   const clean = source.replace(/\\\r?\n/gu, "");
   const tokens = [];
@@ -673,6 +803,11 @@ function createBcCommand(options = {}) {
     description: "Arbitrary-precision calculator language",
     runtimeIdentity: commandRuntimeIdentity,
     async execute(context) {
+      let inputBytes = 0;
+      const admit = (bytes) => {
+        context.signal.throwIfAborted();
+        context.inputBudget?.check(inputBytes += bytes);
+      };
       context.signal.throwIfAborted();
       try {
         let mathlib = false;
@@ -721,14 +856,15 @@ function createBcCommand(options = {}) {
         }
         const sources = [...expressions];
         if (files.length === 0 && expressions.length === 0) {
-          sources.push(decoder.decode(await collectSourceBytes(context.stdin, context.signal, maxInputBytes)));
+          sources.push(decoder.decode(await collectSourceBytes(context.stdin, context.signal, maxInputBytes, admit)));
         } else if (files.length > 0) {
           for (const file of files) {
             if (file === "-") {
-              sources.push(decoder.decode(await collectSourceBytes(context.stdin, context.signal, maxInputBytes)));
+              sources.push(decoder.decode(await collectSourceBytes(context.stdin, context.signal, maxInputBytes, admit)));
             } else {
-              const raw = await context.fs.readFile(pathPosix.resolve(context.cwd, file));
+              const raw = await context.fs.readFile(pathPosix.resolve(context.cwd, file), { signal: context.signal });
               context.signal.throwIfAborted();
+              admit(raw.byteLength);
               if (raw.byteLength > maxInputBytes) throw new Error(`bc program exceeds maximum input size (${maxInputBytes} bytes)`);
               sources.push(decoder.decode(raw));
             }
@@ -750,6 +886,9 @@ function createBcCommand(options = {}) {
         let steps = 0;
         let outBuffer = "";
         let outputBytes = 0;
+        const configuredWidth = Number(context.env.BC_LINE_LENGTH ?? 70);
+        const lineLength = Number.isSafeInteger(configuredWidth) && (configuredWidth === 0 || configuredWidth > 1) ? configuredWidth : 70;
+        let outputColumn = 0;
         const appendOutput = (text) => {
           if (limits.maxOutputBytes !== Infinity) {
             outputBytes += encoder.encode(text).byteLength;
@@ -758,6 +897,19 @@ function createBcCommand(options = {}) {
             }
           }
           outBuffer += text;
+          const newline = text.lastIndexOf("\n");
+          outputColumn = newline < 0 ? outputColumn + text.length : text.length - newline - 1;
+        };
+        const appendNumber = (value) => {
+          let text = formatDecimalInBase(value, obase);
+          if (lineLength !== 0) {
+            while (outputColumn + text.length >= lineLength) {
+              const count = Math.max(0, lineLength - outputColumn - 1);
+              appendOutput(text.slice(0, count) + "\\\n");
+              text = text.slice(count);
+            }
+          }
+          appendOutput(text);
         };
         const tick = () => {
           context.signal.throwIfAborted();
@@ -859,7 +1011,7 @@ function createBcCommand(options = {}) {
               else if (expr.op === "*=") next = mulDec(cur, r, scale);
               else if (expr.op === "/=") next = divDec(cur, r, scale);
               else if (expr.op === "%=") next = modDec(cur, r, scale);
-              else next = powDec(cur, r, scale, limits.maxExponent);
+              else next = await powDec(cur, r, scale, limits.maxExponent, tick);
               return setVar(expr.target.name, expr.target.index, next);
             }
             case "unary": {
@@ -903,7 +1055,7 @@ function createBcCommand(options = {}) {
                 case "%":
                   return modDec(l, r, scale);
                 case "^":
-                  return powDec(l, r, scale, limits.maxExponent);
+                  return await powDec(l, r, scale, limits.maxExponent, tick);
                 case "==":
                   return cmpDec(l, r) === 0 ? ONE : ZERO;
                 case "!=":
@@ -1021,7 +1173,7 @@ function createBcCommand(options = {}) {
                 } else {
                   const v = await evalExpr(item);
                   last = v;
-                  appendOutput(formatDecimalInBase(v, obase));
+                  appendNumber(v);
                 }
               }
               return;
@@ -1041,7 +1193,8 @@ function createBcCommand(options = {}) {
               const val = await evalExpr(stmt.expr);
               if (stmt.expr.kind !== "assign" || stmt.expr.parenthesized) {
                 last = val;
-                appendOutput(formatDecimalInBase(val, obase) + "\n");
+                appendNumber(val);
+                appendOutput("\n");
               }
               return;
             }
@@ -1064,7 +1217,7 @@ function createBcCommand(options = {}) {
         return { exitCode: 0 };
       } catch (err) {
         context.signal.throwIfAborted();
-        if (err instanceof Error && err.name === "AbortError") throw err;
+        if (err instanceof Error && (err.name === "AbortError" || err.name === "BudgetExceededError")) throw err;
         const msg = err instanceof Error ? err.message : String(err);
         const code = err instanceof UsageError ? 2 : 1;
         await writeText(context.stderr, `bc: ${msg}

package/dist/safe-bash-command-bzip2/index.js

@@ -6,7 +6,8 @@ import {
 init_buffer();
 import { PublicDiagnostic, UsageError } from "../safe-bash-contracts/diagnostics.js";
 import {
-  commandRuntimeIdentity
+  commandRuntimeIdentity,
+  withInputByteBudget
 } from "../safe-bash-contracts/index.js";
 import { codeOf, diagnostic, output } from "../safe-bash-compression-engine/internal.js";
 import { runOperand } from "../safe-bash-compression-engine/operand.js";
@@ -35,7 +36,7 @@ function createNamedBzip2Command(name, options = {}) {
     name,
     description: `${name} block-sorting file compressor`,
     runtimeIdentity: commandRuntimeIdentity,
-    async execute(context) {
+    execute: withInputByteBudget(async (context) => {
       context.signal.throwIfAborted();
       try {
         const parsed = parseOptions(name, context.args);
@@ -105,7 +106,7 @@ No FILE or FILE '-' uses stdin; file output uses private VFS staging.
         await diagnostic(context, error);
         return { exitCode: error instanceof UsageError ? 2 : 1 };
       }
-    }
+    })
   };
 }
 function createBzip2Command(options = {}) {

package/dist/safe-bash-command-chmod/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Poe Platform
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.