@poe-platform/safe-bash 0.1.744 → 0.1.746

package/dist/safe-bash/commands/basic.js

@@ -8,6 +8,7 @@ import { printfHex } from "./printf-hex.js";
 import { parsePrintfFloat } from "./printf-float.js";
 import { printfDecimal } from "./printf-decimal.js";
 import { parsePrintfDirective } from "./printf-format.js";
+const utf8Encoder = new TextEncoder();
 export const defaultEchoExecutors = new WeakSet();
 export function basicCommands() {
     return [
@@ -94,7 +95,7 @@ export function basicCommands() {
                 await output(context, result + (parsed.flags.has("z") ? "\0" : "\n"));
             }
             return { exitCode: 0 };
-        }),
+        }, 1, 1),
         define("dirname", async (context) => {
             const parsed = options(context.args, "z", { zero: "z" });
             requireOperands(parsed.operands);
@@ -106,7 +107,7 @@ export function basicCommands() {
                 await output(context, parent.slice(0, end) + (parsed.flags.has("z") ? "\0" : "\n"));
             }
             return { exitCode: 0 };
-        }),
+        }, 1, 1),
         printfCommand,
     ].map(command => {
         if (command.name === "echo")
@@ -355,6 +356,75 @@ export function tryFastPrintf(args) {
                     offset += 2;
                     continue;
                 }
+                if (next === 97) {
+                    result += "\x07";
+                    offset += 2;
+                    continue;
+                }
+                if (next === 98) {
+                    result += "\b";
+                    offset += 2;
+                    continue;
+                }
+                if (next === 102) {
+                    result += "\f";
+                    offset += 2;
+                    continue;
+                }
+                if (next === 118) {
+                    result += "\v";
+                    offset += 2;
+                    continue;
+                }
+                if (next === 101 || next === 69) {
+                    result += "\x1b";
+                    offset += 2;
+                    continue;
+                }
+                if (next === 34) {
+                    result += "\"";
+                    offset += 2;
+                    continue;
+                }
+                if (next === 39) {
+                    result += "'";
+                    offset += 2;
+                    continue;
+                }
+                if (next >= 48 && next <= 55) {
+                    let cur = offset + 1;
+                    const end = Math.min(format.length, cur + 3);
+                    let val = 0;
+                    while (cur < end && format.charCodeAt(cur) >= 48 && format.charCodeAt(cur) <= 55) {
+                        val = val * 8 + (format.charCodeAt(cur++) - 48);
+                    }
+                    const byte = val & 255;
+                    if (byte === 0 || byte >= 128)
+                        return undefined;
+                    result += String.fromCharCode(byte);
+                    offset = cur;
+                    continue;
+                }
+                if (next === 120) {
+                    let cur = offset + 2;
+                    const end = Math.min(format.length, cur + 2);
+                    let val = 0;
+                    let digits = 0;
+                    while (cur < end) {
+                        const d = format.charCodeAt(cur);
+                        const n = d >= 48 && d <= 57 ? d - 48 : d >= 65 && d <= 70 ? d - 55 : d >= 97 && d <= 102 ? d - 87 : -1;
+                        if (n < 0)
+                            break;
+                        val = val * 16 + n;
+                        digits++;
+                        cur++;
+                    }
+                    if (digits === 0 || val === 0 || val >= 128)
+                        return undefined;
+                    result += String.fromCharCode(val);
+                    offset = cur;
+                    continue;
+                }
                 return undefined;
             }
             if (ch !== 37) {
@@ -422,15 +492,31 @@ export function tryFastPrintf(args) {
                 const rawVal = args[argument++] ?? "";
                 if (rawVal.includes("\0"))
                     return undefined;
-                // String slicing and padding match byte semantics only for ASCII.
+                let val = rawVal;
+                let valByteLen = rawVal.length;
                 if (precision >= 0 || width > 0) {
-                    for (let i = 0; i < rawVal.length; i++)
-                        if (rawVal.charCodeAt(i) >= 128)
-                            return undefined;
+                    let isAscii = true;
+                    for (let i = 0; i < rawVal.length; i++) {
+                        if (rawVal.charCodeAt(i) >= 128) {
+                            isAscii = false;
+                            break;
+                        }
+                    }
+                    if (isAscii) {
+                        if (precision >= 0 && precision < rawVal.length) {
+                            val = rawVal.slice(0, precision);
+                            valByteLen = val.length;
+                        }
+                    }
+                    else if (precision < 0) {
+                        valByteLen = utf8Encoder.encode(rawVal).byteLength;
+                    }
+                    else {
+                        return undefined;
+                    }
                 }
-                const val = precision >= 0 ? rawVal.slice(0, precision) : rawVal;
-                if (width > val.length) {
-                    const pad = " ".repeat(width - val.length);
+                if (width > valByteLen) {
+                    const pad = " ".repeat(width - valByteLen);
                     result += leftAlign ? val + pad : pad + val;
                 }
                 else {
@@ -439,6 +525,24 @@ export function tryFastPrintf(args) {
                 offset = cur + 1;
                 continue;
             }
+            if (conv === 99 && !zeroPad) {
+                const rawVal = args[argument++] ?? "";
+                if (rawVal.length === 0)
+                    return undefined;
+                const c0 = rawVal.charCodeAt(0);
+                if (c0 === 0 || c0 >= 128)
+                    return undefined;
+                const ch0 = rawVal[0];
+                if (width > 1) {
+                    const pad = " ".repeat(width - 1);
+                    result += leftAlign ? ch0 + pad : pad + ch0;
+                }
+                else {
+                    result += ch0;
+                }
+                offset = cur + 1;
+                continue;
+            }
             if (conv === 100 || conv === 105) {
                 const rawVal = args[argument++] ?? "0";
                 const val = rawVal.length === 0 ? "0" : rawVal;
@@ -536,5 +640,128 @@ export function tryFastPrintf(args) {
     } while (argument < args.length);
     return result;
 }
+export function extractFastPrintfSpecifiers(format) {
+    if (format.length > 256)
+        return undefined;
+    const specs = [];
+    for (let offset = 0; offset < format.length;) {
+        const ch = format.charCodeAt(offset);
+        if (ch === 92) {
+            const next = format.charCodeAt(offset + 1);
+            if (next === 110 || next === 116 || next === 114 || next === 92 ||
+                next === 97 || next === 98 || next === 102 || next === 118 ||
+                next === 101 || next === 69 || next === 34 || next === 39) {
+                offset += 2;
+                continue;
+            }
+            if (next >= 48 && next <= 55) {
+                let cur = offset + 1;
+                const end = Math.min(format.length, cur + 3);
+                let val = 0;
+                while (cur < end && format.charCodeAt(cur) >= 48 && format.charCodeAt(cur) <= 55) {
+                    val = val * 8 + (format.charCodeAt(cur++) - 48);
+                }
+                if ((val & 255) === 0 || (val & 255) >= 128)
+                    return undefined;
+                offset = cur;
+                continue;
+            }
+            if (next === 120) {
+                let cur = offset + 2;
+                const end = Math.min(format.length, cur + 2);
+                let val = 0;
+                let digits = 0;
+                while (cur < end) {
+                    const d = format.charCodeAt(cur);
+                    const n = d >= 48 && d <= 57 ? d - 48 : d >= 65 && d <= 70 ? d - 55 : d >= 97 && d <= 102 ? d - 87 : -1;
+                    if (n < 0)
+                        break;
+                    val = val * 16 + n;
+                    digits++;
+                    cur++;
+                }
+                if (digits === 0 || val === 0 || val >= 128)
+                    return undefined;
+                offset = cur;
+                continue;
+            }
+            return undefined;
+        }
+        if (ch !== 37) {
+            offset++;
+            continue;
+        }
+        const spec = format.charCodeAt(offset + 1);
+        if (spec === 37) {
+            offset += 2;
+            continue;
+        }
+        let cur = offset + 1;
+        let leftAlign = false;
+        let zeroPad = false;
+        while (cur < format.length) {
+            const fc = format.charCodeAt(cur);
+            if (fc === 45) {
+                leftAlign = true;
+                cur++;
+            }
+            else if (fc === 48) {
+                zeroPad = true;
+                cur++;
+            }
+            else
+                break;
+        }
+        if (leftAlign)
+            zeroPad = false;
+        let width = 0;
+        while (cur < format.length) {
+            const dc = format.charCodeAt(cur);
+            if (dc < 48 || dc > 57)
+                break;
+            width = width * 10 + (dc - 48);
+            if (width > 128)
+                return undefined;
+            cur++;
+        }
+        let precision = -1;
+        if (format.charCodeAt(cur) === 46) {
+            cur++;
+            precision = 0;
+            while (cur < format.length) {
+                const dc = format.charCodeAt(cur);
+                if (dc < 48 || dc > 57)
+                    break;
+                precision = precision * 10 + (dc - 48);
+                if (precision > 128)
+                    return undefined;
+                cur++;
+            }
+        }
+        const conv = format.charCodeAt(cur);
+        if (conv === 115 && !zeroPad) {
+            specs.push(precision < 0 ? "s" : "s_prec");
+            offset = cur + 1;
+            continue;
+        }
+        if (conv === 99 && !zeroPad) {
+            specs.push("c");
+            offset = cur + 1;
+            continue;
+        }
+        if (conv === 100 || conv === 105) {
+            specs.push("d");
+            offset = cur + 1;
+            continue;
+        }
+        if (conv === 120 || conv === 88 || conv === 111 || conv === 117) {
+            specs.push("u");
+            offset = cur + 1;
+            continue;
+        }
+        return undefined;
+    }
+    return specs;
+}
 export const printfCommand = define("printf", formatPrintf, 1, 1);
 //# sourceMappingURL=basic.js.map

package/dist/safe-bash/commands/pr/index.browser.js

@@ -2,7 +2,7 @@ import {
   createPrCommand,
   createPrCommands,
   prCommands
-} from "../../chunks/chunk-I3DOFJSJ.js";
+} from "../../chunks/chunk-MUWJPSGN.js";
 import "../../chunks/chunk-BI6JV62X.js";
 import "../../chunks/chunk-2G2T5MEM.js";
 import "../../chunks/chunk-JYGWVGEJ.js";

package/dist/safe-bash/commands/streams.js

@@ -713,7 +713,7 @@ async function executeHeadTailSlow(name, maxTailFollowHandles, context) {
 }
 function headTail(name, maxTailFollowHandles = Infinity) {
     return define(name, context => {
-        if (name === "head" || name === "tail") {
+        if (name === "head") {
             const a = context.args;
             let fastCount = -1;
             if (a.length === 0) {
@@ -746,62 +746,15 @@ function headTail(name, maxTailFollowHandles = Infinity) {
                 fastCount = n;
             }
             if (fastCount >= 0) {
-                if (name === "head") {
-                    assertCommandRequirements(context, inspectedInputRequirements, STDIN_REQUIREMENT_MODES);
-                    try {
-                        const p = prefixSyncOrAsync(context, input(context, "-"), fastCount, false, false, 10);
-                        if (p === undefined)
-                            return RESOLVED_EXIT_ZERO;
-                        return finishHeadTailPromise(context, p);
-                    }
-                    catch (error) {
-                        return diagnostic(context, error).then(RETURN_EXIT_ONE);
-                    }
+                assertCommandRequirements(context, inspectedInputRequirements, STDIN_REQUIREMENT_MODES);
+                try {
+                    const p = prefixSyncOrAsync(context, input(context, "-"), fastCount, false, false, 10);
+                    if (p === undefined)
+                        return RESOLVED_EXIT_ZERO;
+                    return finishHeadTailPromise(context, p);
                 }
-                else {
-                    const req = assertInputRequirements(context, SINGLE_STDIN_OPERAND);
-                    if (!req) {
-                        assertCommandRequirements(context, inspectedInputRequirements, STDIN_REQUIREMENT_MODES);
-                        const iter = input(context, "-")[Symbol.asyncIterator]();
-                        if (typeof iter.tryNextSync === "function") {
-                            try {
-                                const res1 = iter.tryNextSync();
-                                if (res1 !== undefined) {
-                                    if (res1.done)
-                                        return RESOLVED_EXIT_ZERO;
-                                    const chunk = res1.value;
-                                    const res2 = iter.tryNextSync();
-                                    if (res2 !== undefined && res2.done && chunk.length <= bufferLimit) {
-                                        if (fastCount === 0 || chunk.length === 0)
-                                            return RESOLVED_EXIT_ZERO;
-                                        let pos = chunk[chunk.length - 1] === 10 ? chunk.length - 2 : chunk.length - 1;
-                                        let startIdx = 0;
-                                        for (let rem = fastCount; rem > 0; rem--) {
-                                            if (pos < 0) {
-                                                startIdx = 0;
-                                                break;
-                                            }
-                                            const nl = chunk.lastIndexOf(10, pos);
-                                            if (nl === -1) {
-                                                startIdx = 0;
-                                                break;
-                                            }
-                                            startIdx = nl + 1;
-                                            pos = nl - 1;
-                                        }
-                                        const slice = startIdx === 0 ? chunk : chunk.subarray(startIdx);
-                                        const p = output(context, slice);
-                                        if (isSyncResolved(p))
-                                            return RESOLVED_EXIT_ZERO;
-                                        return finishHeadTailPromise(context, p);
-                                    }
-                                }
-                            }
-                            catch (error) {
-                                return diagnostic(context, error).then(RETURN_EXIT_ONE);
-                            }
-                        }
-                    }
+                catch (error) {
+                    return diagnostic(context, error).then(RETURN_EXIT_ONE);
                 }
             }
         }

package/dist/safe-bash/commands/table-text/index.js

@@ -1,10 +1,14 @@
+import { builtInDirectContextExecutors } from "../internal.js";
 import { createPasteCommand } from "./paste.js";
 import { createCommCommand } from "./comm.js";
 import { createJoinCommand } from "./join.js";
 import { settings } from "./internal.js";
 export function createTableTextCommands(options = {}) {
     settings(options);
-    return [createPasteCommand(options), createCommCommand(options), createJoinCommand(options)];
+    const defs = [createPasteCommand(options), createCommCommand(options), createJoinCommand(options)];
+    for (let i = 0; i < defs.length; i++)
+        builtInDirectContextExecutors.add(defs[i].execute);
+    return defs;
 }
 export function tableTextCommands(options = {}) {
     const commands = createTableTextCommands(options);

package/dist/safe-bash/commands/text.js

@@ -2363,6 +2363,7 @@ async function executeUniqGeneral(context, preReadSource) {
     const onlyRepeated = parsed.flags.has("d");
     const onlyUnique = parsed.flags.has("u");
     const identityKey = skipFields === 0 && skipCharacters === 0 && width === Infinity && !ignoreCase;
+    const uniqDecoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
     const key = (bytes) => {
         if (identityKey)
             return bytes;
@@ -2373,8 +2374,18 @@ async function executeUniqGeneral(context, preReadSource) {
             while (offset < bytes.length && bytes[offset] !== 32 && bytes[offset] !== 9)
                 offset++;
         }
-        offset += skipCharacters;
-        const result = bytes.subarray(offset, width === Infinity ? undefined : offset + width);
+        let result;
+        try {
+            const chars = Array.from(uniqDecoder.decode(bytes.subarray(offset)));
+            result = encoder.encode((width === Infinity ? chars.slice(skipCharacters) : chars.slice(skipCharacters, skipCharacters + width)).join(""));
+        }
+        catch (error) {
+            if (!(error instanceof TypeError))
+                throw error;
+            // Invalid UTF-8 records retain byte comparisons without replacement characters.
+            offset += skipCharacters;
+            result = bytes.subarray(offset, width === Infinity ? undefined : offset + width);
+        }
         return ignoreCase ? fold(result) : result;
     };
     const records = (async function* () {

package/dist/safe-bash/commands/time-env/shared.js

@@ -8,8 +8,8 @@ export function settings(options) {
             throw new RangeError(`Invalid time-env limit: ${name}`);
     }
     const maxTimerMilliseconds = options.maxTimerMilliseconds ?? 2147483647;
-    if (!Number.isInteger(maxTimerMilliseconds) || maxTimerMilliseconds < 1 || maxTimerMilliseconds > 2147483647) {
-        throw new RangeError("maxTimerMilliseconds must be between1 and2147483647");
+    if (maxTimerMilliseconds !== Infinity && (!Number.isInteger(maxTimerMilliseconds) || maxTimerMilliseconds < 1 || maxTimerMilliseconds > 2147483647)) {
+        throw new RangeError("maxTimerMilliseconds must be between 1 and 2147483647 or Infinity");
     }
     const scheduler = options.scheduler ?? {
         now: () => performance.now(),

package/dist/safe-bash/commands/time-env/sleep.js

@@ -96,7 +96,8 @@ function delay(milliseconds, signal, configuration) {
         let handle;
         let armed = false;
         let settled = false;
-        let started;
+        let remaining = milliseconds;
+        let step = 0;
         let previous;
         const finish = (failed, reason) => {
             if (settled)
@@ -128,14 +129,15 @@ function delay(milliseconds, signal, configuration) {
                 if (!Number.isFinite(now) || Math.abs(now) > Number.MAX_SAFE_INTEGER || (previous !== undefined && now < previous)) {
                     throw new RangeError("sleep scheduler must supply finite monotonic milliseconds");
                 }
-                started ??= now;
+                if (previous !== undefined)
+                    remaining -= Math.max(step, now - previous);
                 previous = now;
-                const remaining = milliseconds - (now - started);
                 if (remaining <= 0) {
                     finish(false);
                     return;
                 }
-                const timer = scheduler.setTimeout(() => { armed = false; schedule(); }, Math.min(configuration.maxTimerMilliseconds, Math.max(1, Math.ceil(remaining))));
+                step = Math.min(2147483647, configuration.maxTimerMilliseconds, Math.max(1, Math.ceil(remaining)));
+                const timer = scheduler.setTimeout(() => { armed = false; schedule(); }, step);
                 if (settled)
                     scheduler.clearTimeout(timer);
                 else {

package/dist/safe-bash/commands/timeout/index.d.ts

@@ -4,7 +4,14 @@ export interface TimeoutScheduler {
     setTimeout(callback: () => void, milliseconds: number): unknown;
     clearTimeout(handle: unknown): void;
 }
+export interface TimeoutLimits {
+    readonly maxArguments: number;
+    readonly maxArgumentBytes: number;
+    /** Bytes emitted by timeout itself; child output uses the child's budgets. */
+    readonly maxOutputBytes: number;
+}
 export interface TimeoutCommandOptions {
+    readonly limits?: Partial<TimeoutLimits> | undefined;
     /** Trusted host binding responsible for signalling, hard escalation and child cleanup. */
     readonly killAfterPolicy?: KillAfterPolicy | undefined;
     readonly invoke?: CommandInvoker | undefined;