@poe-platform/safe-bash 0.1.50 → 0.1.52

package/dist/safe-bash/browser.js

@@ -4822,47 +4822,62 @@ function evaluateArithmetic(program, variables) {
         throw new Error(`Unsupported arithmetic operator ${operator}`);
     }
   };
-  const evaluate = (node) => {
-    if (++steps > 1e4) throw new Error("Arithmetic operation limit exceeded");
-    let value2;
-    if (node.kind === "literal") return node.value;
-    if (node.kind === "name") {
-      if (visiting.has(node.name) || visiting.size >= 64) throw new Error("Arithmetic variable recursion");
-      visiting.add(node.name);
-      try {
-        return evaluate(parseArithmetic(variables[node.name] ?? "0"));
-      } finally {
-        visiting.delete(node.name);
-      }
-    }
-    if (node.kind === "conditional") return evaluate(evaluate(node.condition) ? node.yes : node.no);
-    if (node.kind === "unary") {
-      const operand = evaluate(node.operand);
-      if (node.operator === "+") value2 = operand;
-      else if (node.operator === "-") value2 = -operand;
-      else if (node.operator === "!") value2 = BigInt(!operand);
-      else if (node.operator === "~") value2 = ~operand;
-      else {
-        value2 = BigInt.asIntN(64, operand + (node.operator === "++" ? 1n : -1n));
-        variables[node.operand.name] = String(value2);
-        if (node.postfix) value2 = operand;
-      }
-    } else {
-      if (node.operator === "=") value2 = evaluate(node.right);
-      else {
-        const left = evaluate(node.left);
-        if (node.operator === "&&") return left ? BigInt(evaluate(node.right) !== 0n) : 0n;
-        if (node.operator === "||") return left ? 1n : BigInt(evaluate(node.right) !== 0n);
-        if (node.operator === ",") return evaluate(node.right);
-        value2 = binary(precedence[node.operator] === 2 ? node.operator.slice(0, -1) : node.operator, left, evaluate(node.right), node.right.start ?? 0);
-      }
-      if (precedence[node.operator] === 2) variables[node.left.name] = String(BigInt.asIntN(64, value2));
-    }
-    return BigInt.asIntN(64, value2);
-  };
   try {
     if (program.error) throw program.error;
-    return evaluate(program.tree);
+    const pending = [{ kind: "evaluate", node: program.tree }];
+    let value2 = 0n;
+    while (pending.length) {
+      const frame = pending.pop();
+      if (frame.kind === "evaluate") {
+        if (++steps > 1e4) throw new Error("Arithmetic operation limit exceeded");
+        const node = frame.node;
+        if (node.kind === "literal") value2 = node.value;
+        else if (node.kind === "name") {
+          if (visiting.has(node.name) || visiting.size >= 64) throw new Error("Arithmetic variable recursion");
+          visiting.add(node.name);
+          pending.push({ kind: "variable", name: node.name }, { kind: "evaluate", node: parseArithmetic(variables[node.name] ?? "0") });
+        } else if (node.kind === "conditional") {
+          pending.push({ kind: "conditional", node }, { kind: "evaluate", node: node.condition });
+        } else if (node.kind === "unary") {
+          pending.push({ kind: "unary", node }, { kind: "evaluate", node: node.operand });
+        } else if (node.operator === "=") {
+          pending.push({ kind: "right", node }, { kind: "evaluate", node: node.right });
+        } else {
+          pending.push({ kind: "left", node }, { kind: "evaluate", node: node.left });
+        }
+      } else if (frame.kind === "variable") visiting.delete(frame.name);
+      else if (frame.kind === "conditional") {
+        pending.push({ kind: "evaluate", node: value2 ? frame.node.yes : frame.node.no });
+      } else if (frame.kind === "unary") {
+        const { node } = frame;
+        const operand = value2;
+        if (node.operator === "+") value2 = operand;
+        else if (node.operator === "-") value2 = -operand;
+        else if (node.operator === "!") value2 = BigInt(!operand);
+        else if (node.operator === "~") value2 = ~operand;
+        else {
+          value2 = BigInt.asIntN(64, operand + (node.operator === "++" ? 1n : -1n));
+          variables[node.operand.name] = String(value2);
+          if (node.postfix) value2 = operand;
+        }
+        value2 = BigInt.asIntN(64, value2);
+      } else if (frame.kind === "left") {
+        const { node } = frame;
+        if (node.operator === "&&" || node.operator === "||") {
+          if (node.operator === "&&" ? value2 === 0n : value2 !== 0n) value2 = BigInt(value2 !== 0n);
+          else pending.push({ kind: "logical" }, { kind: "evaluate", node: node.right });
+        } else {
+          if (node.operator !== ",") pending.push({ kind: "right", node, left: value2 });
+          pending.push({ kind: "evaluate", node: node.right });
+        }
+      } else if (frame.kind === "right") {
+        const { node } = frame;
+        if (node.operator !== "=") value2 = binary(precedence[node.operator] === 2 ? node.operator.slice(0, -1) : node.operator, frame.left, value2, node.right.start ?? 0);
+        if (precedence[node.operator] === 2) variables[node.left.name] = String(BigInt.asIntN(64, value2));
+        value2 = BigInt.asIntN(64, value2);
+      } else value2 = BigInt(value2 !== 0n);
+    }
+    return value2;
   } catch (error) {
     if (error instanceof ArithmeticFailure) throw new Error(`${program.source.trimStart()}: ${error.message} (error token is "${program.source.slice(error.offset)}")`);
     if (error instanceof ShellSyntaxError) {
@@ -9513,6 +9528,7 @@ var defaultLimits = {
   maxInputBytes: 32 * 1024 * 1024,
   maxOutputBytes: 16 * 1024 * 1024,
   maxCommands: 1e4,
+  maxPipelineStages: 64,
   maxLoopIterations: 1e4,
   maxSubstitutionDepth: 64,
   maxSourceBytes: 1024 * 1024,
@@ -9612,6 +9628,7 @@ var Budget = class {
   signal;
   #wallClockTimer;
   #wallClockDeadline = 0;
+  #pipelineStages = 0;
   #cpuStarted = monotonicNow();
   #armWallClock() {
     const remaining = this.#wallClockDeadline - Date.now();
@@ -9641,6 +9658,17 @@ var Budget = class {
     this.signal.throwIfAborted();
     if (++this.commands > this.limits.maxCommands) this.fail("maxCommands");
   }
+  reservePipelineStages(count) {
+    this.signal.throwIfAborted();
+    if (count > this.limits.maxPipelineStages - this.#pipelineStages) this.fail("maxPipelineStages");
+    this.#pipelineStages += count;
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      this.#pipelineStages -= count;
+    };
+  }
   loop() {
     this.signal.throwIfAborted();
     if (++this.iterations > this.limits.maxLoopIterations) this.fail("maxLoopIterations");
@@ -11136,119 +11164,142 @@ var Runtime = class _Runtime {
     let status;
     if (pipeline.commands.length === 1) status = await this.command(pipeline.commands[0], state, io, false, pipeline.negate);
     else {
-      const pipes = pipeline.commands.slice(1).map(() => createBytePipe({
-        highWaterMark: this.budget.limits.pipeHighWaterMark,
-        signal: this.signal
-      }));
-      const controllers = pipeline.commands.map(() => new AbortController());
+      const release = this.budget.reservePipelineStages(pipeline.commands.length);
+      const retained = /* @__PURE__ */ new Set();
+      let setupClosed = false;
+      const retain = (work) => {
+        retained.add(work);
+        const settled = () => {
+          retained.delete(work);
+          if (setupClosed && !retained.size) release();
+        };
+        void work.then(settled, settled);
+      };
+      const pipes = [];
+      const controllers = [];
       const written = /* @__PURE__ */ new Set();
       const completed = /* @__PURE__ */ new Set();
       const closing = /* @__PURE__ */ new Set();
-      const tasks = pipeline.commands.map(async (command, index) => {
-        const incoming = pipes[index - 1];
-        const outgoing = pipes[index];
-        const childDepth = this.cancellationDepth + 1;
-        const controls = [
-          { role: "pipeline-control", signal: controllers[index].signal }
-        ];
-        const prepared = prepareChildCancellation(
-          this.cancellation,
-          void 0,
-          this.cancellationAdmission(childDepth, controls.length),
-          controls
-        );
-        const owner = new InvocationCancellationOwner(io[invocationScope], prepared, this.cancellationState);
-        let boundary;
-        try {
-          boundary = owner.activate();
-        } catch (error) {
-          await owner.abandon(Promise.resolve());
-          throw error;
-        }
-        const signal = AbortSignal.any([boundary.deliverySignal, io[invocationScope].signal]);
-        const frame = {};
-        const runtime = new _Runtime(
-          this.fs,
-          this.commands,
-          this.middleware,
-          this.budget,
-          signal,
-          this.fileWrites,
-          this.outputFiles,
-          boundary.deliverySignal,
-          boundary,
-          this.cancellationState,
-          owner,
-          childDepth,
-          this.cancellationMaxDepth,
-          frame
-        );
-        const input2 = new ShellInput(incoming?.readable ?? io.stdin, this.budget, signal);
-        const pipeOutput = outgoing && { ownedOutput: outgoing.writable.ownedOutput, write: async (chunk) => {
+      let statuses;
+      try {
+        for (let index = 1; index < pipeline.commands.length; index++) pipes.push(createBytePipe({
+          highWaterMark: this.budget.limits.pipeHighWaterMark,
+          signal: this.signal
+        }));
+        for (let index = 0; index < pipeline.commands.length; index++) controllers.push(new AbortController());
+        const tasks = pipeline.commands.map(async (command, index) => {
+          const incoming = pipes[index - 1];
+          const outgoing = pipes[index];
+          const childDepth = this.cancellationDepth + 1;
+          const controls = [
+            { role: "pipeline-control", signal: controllers[index].signal }
+          ];
+          const prepared = prepareChildCancellation(
+            this.cancellation,
+            void 0,
+            this.cancellationAdmission(childDepth, controls.length),
+            controls
+          );
+          const owner = new InvocationCancellationOwner(io[invocationScope], prepared, this.cancellationState);
+          let boundary;
           try {
-            await outgoing.writable.write(chunk);
-            if (chunk.byteLength) written.add(index);
+            boundary = owner.activate();
           } catch (error) {
-            if (errorCode(error) === "EPIPE") {
-              const closed = new PipelineClosed();
-              controllers[index].abort(closed);
-              throw closed;
-            }
+            await owner.abandon(Promise.resolve());
             throw error;
           }
-        } };
-        const executeStage = async () => {
-          try {
-            let exitCode;
+          const signal = AbortSignal.any([boundary.deliverySignal, io[invocationScope].signal]);
+          const frame = {};
+          const runtime = new _Runtime(
+            this.fs,
+            this.commands,
+            this.middleware,
+            this.budget,
+            signal,
+            this.fileWrites,
+            this.outputFiles,
+            boundary.deliverySignal,
+            boundary,
+            this.cancellationState,
+            owner,
+            childDepth,
+            this.cancellationMaxDepth,
+            frame
+          );
+          const input2 = new ShellInput(incoming?.readable ?? io.stdin, this.budget, signal);
+          const pipeOutput = outgoing && { ownedOutput: outgoing.writable.ownedOutput, write: async (chunk) => {
             try {
-              const child = await cloneState(state, this.signal);
-              child.isolated = true;
-              exitCode = await interruptible(runtime.runCommandIsolated(command, child, {
-                ...isolateIO(io),
-                stdin: input2,
-                ...incoming ? { stdinIsDefault: false } : {},
-                stdout: pipeOutput ? this.budget.sink(pipeOutput, signal) : signalSink(io.stdout, signal),
-                stderr: signalSink(io.stderr, signal)
-              }).finally(() => stateMonitor(child)?.closeValues()), signal);
+              await outgoing.writable.write(chunk);
+              if (chunk.byteLength) written.add(index);
             } catch (error) {
-              if (!(error instanceof PipelineClosed)) throw error;
-              exitCode = 141;
+              if (errorCode(error) === "EPIPE") {
+                const closed = new PipelineClosed();
+                controllers[index].abort(closed);
+                throw closed;
+              }
+              throw error;
             }
-            return { exitCode };
-          } finally {
-            completed.add(index);
-            if (incoming) {
-              const upstream = index - 1;
-              const close = scheduleTurn(() => {
-                closing.delete(close);
-                if (written.has(upstream) && !completed.has(upstream)) controllers[upstream].abort(new PipelineClosed());
+          } };
+          const executeStage = async () => {
+            try {
+              let exitCode;
+              try {
+                const child = await cloneState(state, this.signal);
+                child.isolated = true;
+                const work = runtime.runCommandIsolated(command, child, {
+                  ...isolateIO(io),
+                  stdin: input2,
+                  ...incoming ? { stdinIsDefault: false } : {},
+                  stdout: pipeOutput ? this.budget.sink(pipeOutput, signal) : signalSink(io.stdout, signal),
+                  stderr: signalSink(io.stderr, signal)
+                }).finally(() => stateMonitor(child)?.closeValues());
+                retain(work);
+                exitCode = await interruptible(work, signal);
+              } catch (error) {
+                if (!(error instanceof PipelineClosed)) throw error;
+                exitCode = 141;
+              }
+              return { exitCode };
+            } finally {
+              completed.add(index);
+              if (incoming) {
+                const upstream = index - 1;
+                const close = scheduleTurn(() => {
+                  closing.delete(close);
+                  if (written.has(upstream) && !completed.has(upstream)) controllers[upstream].abort(new PipelineClosed());
+                });
+                closing.add(close);
+                await incoming.abort();
+              }
+              await input2.close().catch((error) => {
+                if (!(error instanceof PipelineClosed)) throw error;
               });
-              closing.add(close);
-              await incoming.abort();
+              if (outgoing) await outgoing.close().catch(() => void 0);
             }
-            await input2.close().catch((error) => {
-              if (!(error instanceof PipelineClosed)) throw error;
-            });
-            if (outgoing) await outgoing.close().catch(() => void 0);
+          };
+          let captured;
+          try {
+            captured = { kind: "return", value: await executeStage() };
+          } catch (reason) {
+            captured = frame.report && Object.is(frame.report.origin.signal.reason, reason) ? { kind: "throw", reason, report: frame.report } : { kind: "throw", reason };
           }
-        };
-        let captured;
-        try {
-          captured = { kind: "return", value: await executeStage() };
-        } catch (reason) {
-          captured = frame.report && Object.is(frame.report.origin.signal.reason, reason) ? { kind: "throw", reason, report: frame.report } : { kind: "throw", reason };
-        }
-        const selection = await owner.finish(Promise.resolve(), captured);
-        if (selection.outcome.kind === "throw") throw selection.outcome.reason;
-        return selection.outcome.value.exitCode;
-      });
-      let statuses;
-      try {
+          const selection = await owner.finish(Promise.resolve(), captured);
+          if (selection.outcome.kind === "throw") throw selection.outcome.reason;
+          return selection.outcome.value.exitCode;
+        });
+        for (const task of tasks) retain(task);
         statuses = await interruptible(Promise.all(tasks), this.signal);
       } finally {
-        for (const close of closing) cancelTurn(close);
-        for (const [index, controller] of controllers.entries()) if (!completed.has(index) || written.has(index)) controller.abort(new PipelineClosed());
-        await Promise.all(pipes.map((pipe) => pipe.abort()));
+        try {
+          for (const close of closing) cancelTurn(close);
+          for (const [index, controller] of controllers.entries()) if (!completed.has(index) || written.has(index)) controller.abort(new PipelineClosed());
+          const aborts = pipes.map((pipe) => pipe.abort());
+          for (const abort of aborts) retain(abort);
+          await Promise.all(aborts);
+        } finally {
+          setupClosed = true;
+          if (!retained.size) release();
+        }
       }
       await this.publishStatus(state, statuses, io);
       status = state.pipefail ? statuses.findLast((status2) => status2 !== 0) ?? 0 : statuses.at(-1);
@@ -15154,6 +15205,7 @@ var cloudflareWorkerLimits = Object.freeze({
   maxInputBytes: 4 * 1024 * 1024,
   maxOutputBytes: 4 * 1024 * 1024,
   maxCommands: 1e3,
+  maxPipelineStages: 64,
   maxLoopIterations: 1e3,
   maxSubstitutionDepth: 16,
   maxSourceBytes: 256 * 1024,