@poe-platform/safe-bash 0.1.801 → 0.1.803

package/dist/safe-bash/shell/runtime.js

@@ -163,6 +163,7 @@ export const defaultLimits = {
     maxPathnameComponents: Infinity,
     maxRedirects: Infinity,
     maxPipelineStages: Infinity,
+    maxPipelineBytes: Infinity,
     maxLoopIterations: Infinity,
     maxSubstitutionDepth: Infinity,
     maxFunctionDepth: Infinity,
@@ -453,6 +454,7 @@ function tickSharedWallClockBudgets() {
     }
 }
 export class Budget {
+    pipelineBytes = 0;
     get fileSystemOperations() {
         return this._fileSystemOperations;
     }
@@ -494,7 +496,7 @@ export class Budget {
             this.maxSourceBytesSmi = limits.maxSourceBytes | 0;
         if (limits.maxPipelineStages < 0x3fffffff)
             this.maxPipelineStagesSmi = limits.maxPipelineStages | 0;
-        if (limits.pipeHighWaterMark < 65536)
+        if (limits.pipeHighWaterMark < 65536 || limits.maxPipelineBytes !== Infinity)
             this.canSyncPurePipe = false;
         this.signal = signal ? combineManagedSignals(signal, this.controller.signal) : this.controller.signal;
         if (signal)
@@ -643,6 +645,16 @@ export class Budget {
     set fsOperations(value) {
         this._fileSystemOperations = value;
     }
+    pipelineInput = (bytes) => {
+        if (this.limits.maxPipelineBytes === Infinity)
+            return;
+        this.assertPipelineInput(bytes);
+        this.pipelineBytes += bytes;
+    };
+    assertPipelineInput(bytes) {
+        if (bytes > this.limits.maxPipelineBytes - this.pipelineBytes)
+            this.fail("maxPipelineBytes");
+    }
     reservePipelineStages(count) {
         this.signal.throwIfAborted();
         if (count > this.limits.maxPipelineStages - this._pipelineStages)
@@ -1493,6 +1505,7 @@ class BudgetedPipeStageSink {
         return Boolean(w.open && pipe && !pipe.failed && !pipe.signal?.aborted && pipe.readerReferences && (!pipe.writes || pipe.writes.size === 0) && (pipe.availableBytes ?? 0) < (pipe.highWaterMark ?? 0));
     }
     writeSync(chunk) {
+        this.budget.assertPipelineInput(chunk.byteLength);
         this.budget.bytes += chunk.byteLength;
         this.writable.write(chunk);
         if (chunk.byteLength && this.written)
@@ -7446,282 +7459,6 @@ export class Runtime {
             }
         }
     }
-    tryRunFastConstEchoBatch(entryCachedUnit, sourceLength, state, io) {
-        if (state.noexec)
-            return undefined;
-        let leadingMkdirUnit;
-        let leadingMkdirPaths;
-        let firstCachedUnit = entryCachedUnit;
-        let firstCc = firstCachedUnit.unit.script._fastConstEcho;
-        if (!firstCc) {
-            const nextU = entryCachedUnit.nextCached;
-            if (!nextU || entryCachedUnit.locale !== false || nextU.locale !== false || (entryCachedUnit.unit.script.warnings && entryCachedUnit.unit.script.warnings.length > 0))
-                return undefined;
-            firstCc = nextU.unit.script._fastConstEcho;
-            if (!firstCc)
-                return undefined;
-            const mScript = entryCachedUnit.unit.script;
-            let mPaths = mScript._cachedMkdirPPaths;
-            if (mPaths === undefined) {
-                mPaths = null;
-                if (mScript.lists.length === 1 && !mScript.lists[0].terminator && mScript.lists[0].pipelines.length === 1 && !mScript.lists[0].pipelines[0].negate && mScript.lists[0].pipelines[0].commands.length === 1) {
-                    const mCmd = mScript.lists[0].pipelines[0].commands[0];
-                    if (mCmd.kind === "simple" && mCmd.redirects.length === 0 && mCmd.words.length >= 3 && mCmd.words[0].plain === "mkdir" && mCmd.words[1].plain === "-p") {
-                        const arr = [];
-                        let ok = true;
-                        for (let wi = 2; wi < mCmd.words.length; wi++) {
-                            const wp = mCmd.words[wi].plain;
-                            if (!wp || !isCleanAbsolutePath(wp) || wp === "/" || wp === "/dev" || wp.startsWith("/dev/")) {
-                                ok = false;
-                                break;
-                            }
-                            arr.push(wp);
-                        }
-                        if (ok)
-                            mPaths = arr;
-                    }
-                }
-                mScript._cachedMkdirPPaths = mPaths;
-            }
-            if (!mPaths)
-                return undefined;
-            leadingMkdirUnit = entryCachedUnit;
-            leadingMkdirPaths = mPaths;
-            firstCachedUnit = nextU;
-        }
-        if (this.middleware.length > 0 || io.terminal !== undefined || io.asyncDefaultInput !== undefined || io.admittedHandles !== undefined || (this._fileWrites !== undefined && this._fileWrites.size > 0) || !this._isMemoryBackingFs || !this.backingFs || !this.budget.canRedirect1 || !this.budget.hasInfiniteFsOps || (io.descriptors && (io.descriptors.size > 3 || io.descriptors.get(0)?.closed || io.descriptors.get(1)?.closed || io.descriptors.get(2)?.closed))) {
-            return undefined;
-        }
-        const monitor = ensureStateMonitor(state, this.budget, io[invocationScope]);
-        const rawState = monitor.raw;
-        if (!this.tryStartExtensionsSync(state) || hasActiveExtensions(rawState) || rawState.externalInvocation || hasActiveVariableAttributes(rawState) || guestArrays(state) || rawState.noclobber || rawState.readonlyVariables?.has("PIPESTATUS") || hasShellFunction(rawState, "echo") || rawState.extensions?.builtins.has("echo")) {
-            return undefined;
-        }
-        const def = this.commands.get("echo");
-        if (!def || !defaultEchoExecutors.has(def.execute))
-            return undefined;
-        const store = monitor.store;
-        const existing = store?.get("PIPESTATUS");
-        const psTarget = existing ? "indexed" : pipelineStatusTarget(rawState);
-        if ((psTarget !== "indexed" && psTarget !== "absent") || store?.watches.has("PIPESTATUS") || monitor.hasOverlay("PIPESTATUS"))
-            return undefined;
-        if (existing && (existing.associative || existing.values.size !== 1 || existing.maximum !== 0))
-            return undefined;
-        const elem0 = existing?.values.get(0);
-        if (existing && (!elem0 || elem0.text.bytes !== 1 || existing.references !== 1 || elem0.text.references !== 1))
-            return undefined;
-        const byteLength0 = firstCc.encoded.byteLength;
-        if ((this.budget.bytes + byteLength0 > this.budget.maxOutputBytesSmi && byteLength0 > this.budget.limits.maxOutputBytes - this.budget.bytes) || !this.budget.canFileSystemOperation() || (this.budget.commands + 1 > this.budget.maxCommandsSmi && this.budget.commands + 1 > this.budget.limits.maxCommands)) {
-            return undefined;
-        }
-        const umask = rawState.umask ?? 0o022;
-        if (leadingMkdirUnit !== undefined && leadingMkdirPaths !== undefined) {
-            if ((umask & 0o300) !== 0 || (this._outputFiles !== undefined && this._outputFiles.size > 0) || hasShellFunction(rawState, "mkdir") || rawState.extensions?.builtins.has("mkdir"))
-                return undefined;
-            const mkdirDef = this.commands.get("mkdir");
-            if (!mkdirDef || !defaultMkdirExecutors.has(mkdirDef.execute))
-                return undefined;
-            const dirMode = 0o777 & ~umask;
-            try {
-                for (let mi = 0; mi < leadingMkdirPaths.length; mi++) {
-                    const mp = leadingMkdirPaths[mi];
-                    if (!tryMkdirMemorySync(this.backingFs, mp, true, dirMode, this.commandSignal, firstCc.dirPrefix.startsWith(mp) && firstCc.dirPrefix.length === mp.length + 1 ? firstCc.dirPrefix : undefined))
-                        return undefined;
-                    this.budget.fileSystemOperation();
-                }
-            }
-            catch {
-                this.signal.throwIfAborted();
-                return undefined;
-            }
-            this.budget.commands++;
-            this.budget.parsing.admit(firstCachedUnit.unitsCharged);
-        }
-        const mode = 0o666 & ~umask;
-        try {
-            if (!tryWriteMemoryFileInDirSync(this.backingFs, firstCc.dirPrefix, firstCc.fileName, firstCc.encoded, firstCc.append, mode, this.commandSignal))
-                return undefined;
-        }
-        catch {
-            this.signal.throwIfAborted();
-            return undefined;
-        }
-        this.budget.tick();
-        this.budget.fileSystemOperation();
-        this.budget.bytes += byteLength0;
-        let lastArg = firstCc.arg0;
-        let cur = firstCachedUnit;
-        const vars = rawState.variables;
-        const curLocale = (vars.LC_ALL || vars.LC_CTYPE || vars.LANG) ? byteLocale(vars) : false;
-        const mem = this.backingFs;
-        let deadRmTarget;
-        let deadRmTargetLen = 0;
-        const rmDef = this.commands.get("rm");
-        if (mem.symlinkCount === 0 && curLocale === false && rmDef && defaultRmExecutors.has(rmDef.execute) && !hasShellFunction(rawState, "rm") && !rawState.extensions?.builtins.has("rm")) {
-            const cachedCc = firstCc;
-            let target = cachedCc._cachedRmTarget;
-            let scanCount = cachedCc._cachedScanCount ?? 0;
-            if (target === undefined) {
-                let scan = firstCachedUnit;
-                scanCount = 1;
-                while (scan.nextCached !== undefined && scan.nextCached.locale === false && (!scan.nextCached.unit.script.warnings || scan.nextCached.unit.script.warnings.length === 0) && scan.nextCached.unit.script._fastConstEcho !== undefined) {
-                    scan = scan.nextCached;
-                    scanCount++;
-                }
-                target = null;
-                const after = scan.nextCached;
-                if (after !== undefined && after.locale === false && (!after.unit.script.warnings || after.unit.script.warnings.length === 0) && after.unit.script.lists.length === 1) {
-                    const list0 = after.unit.script.lists[0];
-                    if (!list0.terminator && list0.pipelines.length === 1 && !list0.pipelines[0].negate && list0.pipelines[0].commands.length === 1) {
-                        const cmd0 = list0.pipelines[0].commands[0];
-                        if (cmd0.kind === "simple" && cmd0.redirects.length === 0 && cmd0.words.length === 3 && cmd0.words[0].plain === "rm" && (cmd0.words[1].plain === "-rf" || cmd0.words[1].plain === "-fr")) {
-                            const t = cmd0.words[2].plain;
-                            if (t && t.length > 1 && t.charCodeAt(0) === 47 && t.charCodeAt(t.length - 1) !== 47 && !t.includes("/."))
-                                target = t;
-                        }
-                    }
-                }
-                cachedCc._cachedRmTarget = target;
-                cachedCc._cachedScanCount = scanCount;
-            }
-            if (target !== null && this.budget.commands + scanCount + 1 <= this.budget.maxCommandsSmi && tryGetMemoryDirectoryEntryNamesSync(this.backingFs, target)?.size === 0) {
-                deadRmTarget = target;
-                deadRmTargetLen = target.length;
-            }
-        }
-        const cachedBatchPlan = deadRmTarget !== undefined ? firstCc._cachedEchoBatch : undefined;
-        if (cachedBatchPlan !== undefined && cachedBatchPlan !== null && mem.symlinkCount === 0 && !this.signal.aborted && this.budget.bytes + cachedBatchPlan.totalBytes <= this.budget.maxOutputBytesSmi && this.budget._fileSystemOperations + cachedBatchPlan.totalCount <= this.budget.maxFileSystemOperationsSmi && this.budget.commands + cachedBatchPlan.totalCount <= this.budget.maxCommandsSmi) {
-            this.budget.parsing.admit(cachedBatchPlan.totalUnitsCharged);
-            try {
-                mem.writeMemoryFilesInDirBatchFast(firstCc.fileName, firstCc.dirPrefix, cachedBatchPlan.fileNames, cachedBatchPlan.nameHashes, cachedBatchPlan.payloads, cachedBatchPlan.totalNameBytes, cachedBatchPlan.payloadBytesSum, mode);
-                this.budget.commands += cachedBatchPlan.totalCount;
-                this.budget._fileSystemOperations += cachedBatchPlan.totalCount;
-                this.budget.bytes += cachedBatchPlan.totalBytes;
-                lastArg = cachedBatchPlan.lastArg;
-                cur = cachedBatchPlan.endUnit;
-            }
-            catch {
-                this.signal.throwIfAborted();
-            }
-        }
-        if (cur !== cachedBatchPlan?.endUnit && cur.unit.next < sourceLength && mem.symlinkCount === 0 && !this.signal.aborted) {
-            const buildBatchStart = cur === firstCachedUnit && deadRmTarget !== undefined && cachedBatchPlan === undefined;
-            let bTotalCount = 0;
-            let bTotalBytes = 0;
-            let bTotalUnits = 0;
-            let bTotalNameBytes = 0;
-            let bPayloadBytesSum = 0;
-            let bCanCache = buildBatchStart && !firstCc.append;
-            const bFileNames = bCanCache ? [] : undefined;
-            const bHashes = bCanCache ? [] : undefined;
-            const bPayloads = bCanCache ? [] : undefined;
-            const bSeenNames = bCanCache ? new Set([firstCc.fileName]) : undefined;
-            while (cur.unit.next < sourceLength && mem.symlinkCount === 0 && !this.signal.aborted) {
-                const next = cur.nextCached;
-                if (!next || next.locale !== curLocale || (next.unit.script.warnings && next.unit.script.warnings.length > 0))
-                    break;
-                const nextCc = next.unit.script._fastConstEcho;
-                if (!nextCc)
-                    break;
-                const bLen = nextCc.encoded.byteLength;
-                if (this.budget.bytes + bLen > this.budget.maxOutputBytesSmi || this.budget._fileSystemOperations + 1 > this.budget.maxFileSystemOperationsSmi || this.budget.commands + 1 > this.budget.maxCommandsSmi) {
-                    break;
-                }
-                this.budget.parsing.admit(next.unitsCharged);
-                if (!(deadRmTarget !== undefined && nextCc.dirPrefix.length === deadRmTargetLen + 1 && nextCc.dirPrefix.charCodeAt(deadRmTargetLen) === 47 && nextCc.dirPrefix.startsWith(deadRmTarget))) {
-                    let nameHash = nextCc._nameHash;
-                    if (nameHash === undefined) {
-                        const fn = nextCc.fileName;
-                        let h = 5381;
-                        for (let ci = 0; ci < fn.length; ci++)
-                            h = (((h & 0x1fffff) * 33) ^ fn.charCodeAt(ci)) & 0x3fffffff;
-                        nextCc._nameHash = nameHash = h;
-                    }
-                    try {
-                        mem.writeMemoryFileInDirFast(nextCc.dirPrefix, nextCc.fileName, nextCc.encoded, nextCc.append, mode, nameHash);
-                    }
-                    catch {
-                        this.signal.throwIfAborted();
-                        break;
-                    }
-                }
-                if (bCanCache) {
-                    const isDeadRm = deadRmTarget !== undefined && nextCc.dirPrefix.length === deadRmTargetLen + 1 && nextCc.dirPrefix.charCodeAt(deadRmTargetLen) === 47 && nextCc.dirPrefix.startsWith(deadRmTarget);
-                    if (isDeadRm) {
-                        bTotalCount++;
-                        bTotalBytes += bLen;
-                        bTotalUnits += next.unitsCharged;
-                    }
-                    else if (!nextCc.append && nextCc.dirPrefix === firstCc.dirPrefix && nextCc.fileName.length <= 85 && !bSeenNames.has(nextCc.fileName)) {
-                        bSeenNames.add(nextCc.fileName);
-                        bFileNames.push(nextCc.fileName);
-                        bHashes.push(nextCc._nameHash);
-                        bPayloads.push(nextCc.encoded);
-                        bTotalNameBytes += nextCc.fileName.length * 2;
-                        bPayloadBytesSum += bLen;
-                        bTotalCount++;
-                        bTotalBytes += bLen;
-                        bTotalUnits += next.unitsCharged;
-                    }
-                    else
-                        bCanCache = false;
-                }
-                this.budget.commands++;
-                this.budget._fileSystemOperations++;
-                this.budget.bytes += bLen;
-                lastArg = nextCc.arg0;
-                cur = next;
-            }
-            if (buildBatchStart) {
-                firstCc._cachedEchoBatch = bCanCache && bTotalCount > 0
-                    ? {
-                        endUnit: cur, totalCount: bTotalCount, totalBytes: bTotalBytes, totalUnitsCharged: bTotalUnits, lastArg, fileNames: bFileNames, nameHashes: new Int32Array(bHashes), payloads: bPayloads, totalNameBytes: bTotalNameBytes, payloadBytesSum: bPayloadBytesSum,
-                    }
-                    : null;
-            }
-        }
-        if (deadRmTarget !== undefined && cur.nextCached !== undefined && !this.signal.aborted && mem.symlinkCount === 0 && (this._outputFiles === undefined || this._outputFiles.size === 0) && !hasShellFunction(rawState, "rm") && !rawState.extensions?.builtins.has("rm")) {
-            const rmDef = this.commands.get("rm");
-            const rmUnit = cur.nextCached;
-            const rmCmd0 = rmUnit.unit.script.lists[0]?.pipelines[0]?.commands[0];
-            if (rmDef && defaultRmExecutors.has(rmDef.execute) && rmCmd0 && rmCmd0.kind === "simple" && rmCmd0.words[0]?.plain === "rm" && rmCmd0.words[2]?.plain === deadRmTarget) {
-                let rmOk = false;
-                try {
-                    rmOk = tryRmRfMemorySync(this.backingFs, deadRmTarget, this.commandSignal);
-                }
-                catch {
-                    this.signal.throwIfAborted();
-                }
-                if (rmOk) {
-                    this.budget.parsing.admit(rmUnit.unitsCharged);
-                    this.budget.commands++;
-                    this.budget._fileSystemOperations++;
-                    lastArg = deadRmTarget;
-                    cur = rmUnit;
-                }
-            }
-        }
-        const restEpoch = monitor.chargeInternal(syncRestorationCharge, syncRestorationTickets).epoch;
-        rawState.substitutionStatus = 0;
-        if (rawState.variables._ !== undefined)
-            delete rawState.variables._;
-        rawState.lastArgument = lastArg;
-        if (io.assignmentDiagnosticContext)
-            io.assignmentDiagnosticContext.name = undefined;
-        if (!existing) {
-            monitor.lazyPipeStatus = singleStatusZero;
-            monitor.chargeInternal(syncPipeStatusCharge, syncPipeStatusTickets);
-        }
-        else {
-            elem0.text.shellValue = "0";
-            store.changed(monitor.chargeInternal(syncPipeStatusCharge, syncPipeStatusTickets), "PIPESTATUS");
-        }
-        rawState.status = 0;
-        monitor.epoch = restEpoch;
-        if (store)
-            store.epoch = restEpoch;
-        return cur;
-    }
     tryRunCachedSyncForScript(script, monitor, io) {
         const rawScript = script;
         let plan = rawScript._cachedSyncForScriptPlan;
@@ -7808,6 +7545,9 @@ export class Runtime {
             rawScript._cachedSyncForScriptPlan = plan;
         }
         const forPlan = plan.forCmd._cachedForPlan;
+        // Only integer registers can skip unquoted field splitting and globbing.
+        if (plan.echoVar !== undefined && (!forPlan.touchedIntNamesList.includes(plan.echoVar) || forPlan.touchedIntNamesList.includes("IFS") || (rawState.variables.IFS !== undefined && rawState.variables.IFS !== " \t\n") || plan.initAssigns.some(assignment => assignment.name === "IFS")))
+            return undefined;
         const fastSyncSink = plan.echoVar !== undefined
             ? ((io.stdout instanceof BudgetedSyncSink && io.stdout.write === BudgetedSyncSink.prototype.write) || (io.stdout instanceof Capture && io.stdout.write === Capture.prototype.write) ? io.stdout : undefined)
             : undefined;
@@ -7815,6 +7555,10 @@ export class Runtime {
             const def = this.commands.get("echo");
             if (!fastSyncSink || !def || !defaultEchoExecutors.has(def.execute) || hasShellFunction(rawState, "echo") || rawState.extensions?.builtins.has("echo") || (io.descriptors && io.descriptors.get(1)?.output !== io.stdout))
                 return undefined;
+            // Every signed SMI plus a newline fits in 12 bytes. Admit the bound before
+            // speculative arithmetic; smaller allowances use ordinary execution.
+            if (this.budget.maxOutputBytesSmi - this.budget.bytes < 12)
+                return undefined;
         }
         const store = monitor.store;
         const existing = store?.get("PIPESTATUS");
@@ -7841,36 +7585,40 @@ export class Runtime {
         for (const assignment of plan.initAssigns)
             finalValues.set(assignment.name, assignment.strVal);
         const regNames = forPlan.regNames;
-        for (let r = 1; r < regNames.length; r++) {
-            const refName = regNames[r];
-            const parsed = fastSafeInt(finalValues.get(refName) ?? rawState.variables[refName], this.budget.parsing);
-            if (parsed === undefined)
-                return undefined;
-            sharedLoopIntRegs[r] = parsed | 0;
-        }
-        const { ok } = runIntForLoop(forPlan.fastLoopWords, forPlan.bodyStepCount, forPlan.intSteps, this.budget.parsing);
-        if (!ok)
-            return undefined;
-        for (let r = 0; r < regNames.length; r++)
-            finalValues.set(regNames[r], intToStr(sharedLoopIntRegs[r]));
+        const savedParseBudget = this.budget.parsing.snapshot();
+        let admitted = false;
         let lastArg = "";
-        if (plan.echoVar !== undefined) {
-            const echoVal = finalValues.get(plan.echoVar) ?? rawState.variables[plan.echoVar] ?? "";
-            const ifs = finalValues.get("IFS") ?? rawState.variables.IFS;
-            if (ifs !== undefined && ifs !== " \t\n")
-                return undefined;
-            if (echoVal.startsWith("-") || echoVal.includes("\0"))
-                return undefined;
-            const encoded = encodeRedirectTextWithNewlineToScratch(echoVal);
-            if (!encoded)
-                return undefined;
-            const bLen = encoded.byteLength;
-            if (this.budget.bytes + bLen > this.budget.maxOutputBytesSmi)
-                return undefined;
-            if (!fastSyncSink.writeSync(encoded))
+        try {
+            for (let r = 1; r < regNames.length; r++) {
+                const refName = regNames[r];
+                const parsed = fastSafeInt(finalValues.get(refName) ?? rawState.variables[refName], this.budget.parsing);
+                if (parsed === undefined)
+                    return undefined;
+                sharedLoopIntRegs[r] = parsed | 0;
+            }
+            const { ok } = runIntForLoop(forPlan.fastLoopWords, forPlan.bodyStepCount, forPlan.intSteps, this.budget.parsing);
+            if (!ok)
                 return undefined;
-            this.budget.bytes += bLen;
-            lastArg = echoVal;
+            for (const name of forPlan.touchedIntNamesList)
+                finalValues.set(name, intToStr(sharedLoopIntRegs[regNames.indexOf(name)]));
+            if (plan.echoVar !== undefined) {
+                const echoVal = finalValues.get(plan.echoVar);
+                const encoded = encodeRedirectTextWithNewlineToScratch(echoVal);
+                if (!encoded)
+                    return undefined;
+                const bLen = encoded.byteLength;
+                if (this.budget.bytes + bLen > this.budget.maxOutputBytesSmi)
+                    return undefined;
+                if (!fastSyncSink.writeSync(encoded))
+                    return undefined;
+                this.budget.bytes += bLen;
+                lastArg = echoVal;
+            }
+            admitted = true;
+        }
+        finally {
+            if (!admitted)
+                this.budget.parsing.restore(savedParseBudget);
         }
         for (const [name, value] of finalValues)
             rawState.variables[name] = value;
@@ -8529,7 +8277,7 @@ export class Runtime {
         const n = pipeline.commands.length;
         this.budget.enterPipelineStages(n);
         this.budget.commands += n;
-        const pipeOptions = { highWaterMark: this.budget.limits.pipeHighWaterMark, signal: this.signal };
+        const pipeOptions = { highWaterMark: this.budget.limits.pipeHighWaterMark, signal: this.signal, admitWrite: this.budget.pipelineInput };
         const pipes = new Array(n - 1);
         for (let i = 0; i < n - 1; i++) {
             pipes[i] = createBytePipe(pipeOptions);
@@ -15697,8 +15445,8 @@ export class Runtime {
         this.budget.tick();
         this.budget.iterations += wordCount;
         this.budget.commands += wordCount * forPlan.bodyStepCount;
-        for (let r = 0; r < regNames.length; r++) {
-            rawState.variables[regNames[r]] = intToStr(sharedLoopIntRegs[r]);
+        for (const name of forPlan.touchedIntNamesList) {
+            rawState.variables[name] = intToStr(sharedLoopIntRegs[regNames.indexOf(name)]);
         }
         const touchedList = forPlan.touchedIntNamesList;
         for (let t = 0; t < touchedList.length; t++) {
@@ -17082,8 +16830,8 @@ export class Runtime {
                             rawState.status = 0;
                         }
                         runYieldCheckpoint(this.signal);
-                        for (let r = 0; r < regNames.length; r++) {
-                            rawState.variables[regNames[r]] = intToStr(sharedLoopIntRegs[r]);
+                        for (const name of forPlan.touchedIntNamesList) {
+                            rawState.variables[name] = intToStr(sharedLoopIntRegs[regNames.indexOf(name)]);
                         }
                         regNames.length = 0;
                     }
@@ -18591,7 +18339,7 @@ export class Runtime {
                 }
                 for (let index = 1; index < pipeline.commands.length; index++)
                     pipes.push(createBytePipe({
-                        highWaterMark: this.budget.limits.pipeHighWaterMark, signal: this.signal,
+                        highWaterMark: this.budget.limits.pipeHighWaterMark, signal: this.signal, admitWrite: this.budget.pipelineInput,
                     }));
                 for (let index = 0; index < pipeline.commands.length; index++) {
                     controllers.push(createManagedControlController());
@@ -35741,6 +35489,10 @@ export class Runtime {
         return true;
     }
     tryFastPureSubstitution(part, state, rawState, io) {
+        if (!cCollation(rawState.variables.LC_ALL || rawState.variables.LC_COLLATE || rawState.variables.LANG || "C"))
+            return undefined;
+        if (this.budget.limits.maxPipelineBytes !== Infinity)
+            return undefined;
         // Synchronous evaluators do not expose cumulative source-read accounting.
         // Use the command context whenever the caller has set an input ceiling.
         if (this.budget.limits.maxInputBytes !== Infinity)

package/dist/safe-bash/shell/shell.js

@@ -1,5 +1,4 @@
 var _a;
-import { preverifyMemoryRgTree } from "../commands/search/rg-command.js";
 import { MemoryFileSystem } from "../fs/memory/index.js";
 function utf8ByteLength(str) {
     if (typeof globalThis.Buffer === "function")
@@ -598,27 +597,6 @@ export class Shell {
             let unit = firstCached.unit;
             let exitCode = 0;
             while (true) {
-                if (currentCachedUnit !== undefined && (unit.script._fastConstEcho !== undefined || (currentCachedUnit.nextCached !== undefined && currentCachedUnit.nextCached.unit.script._fastConstEcho !== undefined))) {
-                    const batchEnd = runtime.tryRunFastConstEchoBatch(currentCachedUnit, source.length, currentState, io);
-                    if (batchEnd !== undefined) {
-                        currentCachedUnit = batchEnd;
-                        unit = batchEnd.unit;
-                        exitCode = 0;
-                        if (unit.next >= source.length)
-                            break;
-                        budget.signal.throwIfAborted();
-                        const vars = currentState.variables;
-                        const nextLocale = (vars.LC_ALL || vars.LC_CTYPE || vars.LANG) ? byteLocale(vars) : false;
-                        const nextCached = currentCachedUnit.locale === nextLocale ? currentCachedUnit.nextCached : undefined;
-                        if (nextCached !== undefined && (!nextCached.unit.script.warnings || nextCached.unit.script.warnings.length === 0)) {
-                            currentCachedUnit = nextCached;
-                            budget.parsing.admit(nextCached.unitsCharged);
-                            unit = nextCached.unit;
-                            continue;
-                        }
-                        return this.#continueWarmAsync(source, options, warm, sourceCache, undefined, unit, currentCachedUnit, exitCode);
-                    }
-                }
                 if (unit.script.lists.length) {
                     const unitResult = runtime.runUnit(unit.script, currentState, io);
                     if (unitResult instanceof Promise) {
@@ -1181,7 +1159,6 @@ export class Shell {
                 stdout.enableScratchBuffer();
                 stderr.enableScratchBuffer();
                 void runtime.canFastMemoryRedirect;
-                preverifyMemoryRgTree(runtime.backingFs);
                 this.#warmedInvocation = {
                     budget,
                     scope,

package/dist/safe-bash/shell/types.d.ts

@@ -55,6 +55,8 @@ export interface ShellLimits {
      * Zero permits only redirect-free commands. Not a global byte or filesystem-call budget. */
     readonly maxRedirects?: number;
     readonly maxPipelineStages?: number;
+    /** Cumulative bytes written between pipeline stages per invocation, including nested pipelines. */
+    readonly maxPipelineBytes?: number;
     readonly maxLoopIterations?: number;
     readonly maxSubstitutionDepth?: number;
     /** Maximum simultaneously active shell functions; zero rejects function calls. Unlimited when omitted. */

package/dist/safe-bash/shell/worker-limits.js

@@ -45,6 +45,7 @@ export const cloudflareWorkerLimits = Object.freeze({
     maxPathnameComponents: 64,
     maxRedirects: 64,
     maxPipelineStages: 64,
+    maxPipelineBytes: 4 * 1024 * 1024,
     maxLoopIterations: 1_000,
     maxSubstitutionDepth: 16,
     maxFunctionDepth: 16,

package/dist/safe-bash/shell-entry.browser.js

@@ -1,29 +1,31 @@
+import {
+  cloudflareWorkerLimits
+} from "./chunks/chunk-2LSAMQER.js";
 import {
   Shell,
   ShellLimitError,
   ShellSyntaxError,
-  cloudflareWorkerLimits,
   parseShell
-} from "./chunks/chunk-7VNF5BFF.js";
+} from "./chunks/chunk-B7PIL77G.js";
+import "./chunks/chunk-A7XEHALN.js";
 import "./chunks/chunk-TFIBK2GI.js";
 import "./chunks/chunk-3NDIFSNM.js";
-import "./chunks/chunk-SZH7EJLD.js";
+import "./chunks/chunk-6O77NL2S.js";
+import "./chunks/chunk-PNBBUWSM.js";
 import "./chunks/chunk-MHMMRCYC.js";
+import "./chunks/chunk-OV6IHKO6.js";
+import "./chunks/chunk-CHYGPFVM.js";
 import "./chunks/chunk-AUSNDQTJ.js";
 import "./chunks/chunk-CTVWDACF.js";
 import "./chunks/chunk-3R3AANOR.js";
-import "./chunks/chunk-OV6IHKO6.js";
 import "./chunks/chunk-XVOSKJE2.js";
 import "./chunks/chunk-C5OWC2TL.js";
-import "./chunks/chunk-IVRQ4BXL.js";
+import "./chunks/chunk-PH63PLPZ.js";
 import "./chunks/chunk-D3ANYGMC.js";
-import "./chunks/chunk-CHYGPFVM.js";
-import "./chunks/chunk-6O77NL2S.js";
-import "./chunks/chunk-A7XEHALN.js";
 import "./chunks/chunk-J42RIHHJ.js";
 import "./chunks/chunk-I5HZ4FGE.js";
 import "./chunks/chunk-VTH3MLDU.js";
-import "./chunks/chunk-NZQXYWA3.js";
+import "./chunks/chunk-5OHX7C2V.js";
 import "./chunks/chunk-74GHTNJA.js";
 import {
   CommandRegistry,
@@ -31,8 +33,15 @@ import {
   createCommandArguments,
   getCommandArguments
 } from "./chunks/chunk-7R5BDCG7.js";
-import "./chunks/chunk-IWDICZVK.js";
+import "./chunks/chunk-55YJASTN.js";
+import "./chunks/chunk-4BSJLKNM.js";
+import "./chunks/chunk-DQP3VHSB.js";
+import "./chunks/chunk-GEG3BWGE.js";
+import "./chunks/chunk-VBTDHOWC.js";
+import "./chunks/chunk-QGUV42T5.js";
+import "./chunks/chunk-ZVD5IS4V.js";
 import "./chunks/chunk-E7OYNDGL.js";
+import "./chunks/chunk-IWDICZVK.js";
 import {
   init_platform
 } from "./chunks/chunk-B7TAL7S5.js";

package/dist/safe-bash/worker/host.js

@@ -14,7 +14,7 @@ export function createWorkerKillAfterPolicy(registry, configuration, requiresMod
         // These counters/leases belong to the interpreter, not to a separate Shell.
         // Until a shared ledger is available, refuse rather than reset their quota.
         const limits = runtimeContext?.budget.limits ?? configuration.limits;
-        const shared = ["maxCommands", "maxLoopIterations", "maxSourceBytes", "maxParseUnits", "maxExpansionBytes", "maxExpansionFields", "maxPipelineStages", "maxSubstitutionDepth", "maxFunctionDepth", "maxCpuMs"];
+        const shared = ["maxCommands", "maxLoopIterations", "maxSourceBytes", "maxParseUnits", "maxExpansionBytes", "maxExpansionFields", "maxPipelineStages", "maxPipelineBytes", "maxSubstitutionDepth", "maxFunctionDepth", "maxCpuMs"];
         if (shared.some(key => limits?.[key] !== undefined && limits[key] !== Infinity)) {
             await writeBytes(context.stderr, new TextEncoder().encode("timeout: worker escalation cannot preserve finite shared interpreter quotas\n"), context.signal);
             return { exitCode: 125 };

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

@@ -35,11 +35,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);
   }
@@ -673,6 +674,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 +727,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));
             }
@@ -1064,7 +1071,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}