@poe-platform/safe-bash 0.1.51 → 0.1.53

package/dist/safe-bash/browser.js

@@ -9528,6 +9528,7 @@ var defaultLimits = {
   maxInputBytes: 32 * 1024 * 1024,
   maxOutputBytes: 16 * 1024 * 1024,
   maxCommands: 1e4,
+  maxPipelineStages: 64,
   maxLoopIterations: 1e4,
   maxSubstitutionDepth: 64,
   maxSourceBytes: 1024 * 1024,
@@ -9627,6 +9628,7 @@ var Budget = class {
   signal;
   #wallClockTimer;
   #wallClockDeadline = 0;
+  #pipelineStages = 0;
   #cpuStarted = monotonicNow();
   #armWallClock() {
     const remaining = this.#wallClockDeadline - Date.now();
@@ -9656,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");
@@ -11151,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);
@@ -15169,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,