@poe-platform/safe-bash 0.1.793 → 0.1.794

package/dist/safe-bash/opt-in/optional/commands/shuf/input.js

@@ -4,13 +4,116 @@ import { Diagnostic } from "./args.js";
 export function virtualPath(cwd, name) {
     if (name === "")
         throw new FsError("ENOENT");
-    return name.startsWith("/") ? name : `${cwd.endsWith("/") ? cwd : `${cwd}/`}${name}`;
+    let decoded;
+    try {
+        decoded = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(Uint8Array.from(name, character => character.charCodeAt(0)));
+    }
+    catch {
+        throw new FsError("ENOENT");
+    }
+    return decoded.startsWith("/") ? decoded : `${cwd.endsWith("/") ? cwd : `${cwd}/`}${decoded}`;
+}
+/** Own only acquisition and reads; a capability or pathname query owns no reader. */
+export class FileInput {
+    context;
+    maxBytes;
+    stat;
+    handle;
+    source;
+    opening;
+    closing;
+    closed = false;
+    controller = new AbortController();
+    signal;
+    constructor(context, maxBytes) {
+        this.context = context;
+        this.maxBytes = maxBytes;
+        this.signal = AbortSignal.any([context.signal, this.controller.signal]);
+    }
+    async open(name) {
+        const { fs } = this.context;
+        const signal = this.signal;
+        signal.throwIfAborted();
+        const path = virtualPath(this.context.cwd, name);
+        const capabilities = await fs.capabilitiesFor?.(path, { signal }) ?? fs.capabilities;
+        signal.throwIfAborted();
+        const retained = fs.openReadFile !== undefined && capabilities.retainedRead !== false;
+        if (!retained) {
+            if (capabilities.stat !== false)
+                this.stat = await fs.stat(path, { signal });
+            signal.throwIfAborted();
+        }
+        if (this.closed)
+            throw new FsError("EBADF");
+        this.opening = Promise.resolve().then(async () => {
+            signal.throwIfAborted();
+            let input;
+            if (retained) {
+                this.handle = await fs.openReadFile(path, { signal });
+                signal.throwIfAborted();
+                this.stat = await this.handle.stat({ signal });
+                signal.throwIfAborted();
+                const handle = this.handle;
+                const maximum = Math.min(65536, this.maxBytes);
+                input = { async *[Symbol.asyncIterator]() {
+                        let position = 0;
+                        while (true) {
+                            const bytes = await handle.read(position, maximum, { signal });
+                            signal.throwIfAborted();
+                            if (!bytes.length)
+                                return;
+                            position += bytes.length;
+                            yield new Uint8Array(bytes);
+                        }
+                    } };
+            }
+            else if (fs.readStream && capabilities.streamingRead !== false) {
+                input = fs.readStream(path, { signal, chunkSize: Math.min(65536, this.maxBytes) });
+            }
+            else {
+                if (capabilities.read === false)
+                    throw new FsError("ENOTSUP");
+                const maxBytes = this.maxBytes;
+                input = { async *[Symbol.asyncIterator]() {
+                        const bytes = await fs.readFile(path, { signal, ...(Number.isFinite(maxBytes) ? { maxBytes } : {}) });
+                        if (bytes.byteLength > maxBytes)
+                            throw new Diagnostic("shuf: maxInputBytes limit exceeded\n");
+                        yield bytes;
+                    } };
+            }
+            this.source = ownedBytes(input, signal);
+            signal.throwIfAborted();
+        });
+        await this.opening;
+    }
+    next() {
+        this.signal.throwIfAborted();
+        return this.source.next();
+    }
+    close() {
+        this.closed = true;
+        this.controller.abort(new Error("shuf input is closed"));
+        return this.closing ??= Promise.resolve().then(async () => {
+            await this.opening?.catch(() => { });
+            try {
+                await this.source?.return(undefined);
+            }
+            finally {
+                await this.handle?.close();
+            }
+        });
+    }
+    [Symbol.asyncIterator]() {
+        return { next: () => this.next(), return: async () => { await this.close(); return { done: true, value: undefined }; } };
+    }
 }
 export function ownedBytes(source, signal) {
     const iterator = source[Symbol.asyncIterator]();
     const controller = new AbortController();
     const readingSignal = AbortSignal.any([signal, controller.signal]);
     let finished = false;
+    let failed = false;
+    let failure;
     let closing;
     const close = () => {
         controller.abort(new Error("shuf input is closed"));
@@ -24,9 +127,16 @@ export function ownedBytes(source, signal) {
         [Symbol.asyncIterator]() {
             return {
                 async next() {
-                    const next = await iterator.next();
-                    finished = next.done === true;
-                    return next;
+                    try {
+                        const next = await iterator.next();
+                        finished = next.done === true;
+                        return next;
+                    }
+                    catch (error) {
+                        failed = true;
+                        failure = error;
+                        throw error;
+                    }
                 },
                 return: close,
             };
@@ -41,8 +151,14 @@ export function ownedBytes(source, signal) {
                     await yieldTurn(readingSignal);
             }
         }
+        catch (error) {
+            if (failed)
+                throw failure;
+            throw error;
+        }
         finally {
-            await close();
+            await close().catch(error => { if (!failed)
+                throw error; });
         }
     })();
     return {

package/dist/safe-bash/opt-in/optional/commands/shuf/random.d.ts

@@ -8,6 +8,7 @@ export declare class RandomIntegers {
     private bytes;
     private offset;
     private source;
+    private state;
     private closed;
     private closing;
     private opening;
@@ -16,6 +17,8 @@ export declare class RandomIntegers {
     constructor(context: CommandContext, name: string | undefined, maxBytes?: number);
     open(): Promise<void>;
     close(): Promise<void>;
+    seed(): void;
+    private refill;
     private byte;
     chooseSync(size: bigint): bigint;
     choose(size: bigint): Promise<bigint>;

package/dist/safe-bash/opt-in/optional/commands/shuf/random.js

@@ -1,6 +1,6 @@
 import { yieldTurn } from "@poe-platform/safe-bash/contracts/yield";
-import { Diagnostic, quote, wordMax } from "./args.js";
-import { ownedBytes, virtualPath } from "./input.js";
+import { Diagnostic, quote, unicodeLocale, wordMax } from "./args.js";
+import { FileInput } from "./input.js";
 export class RandomIntegers {
     context;
     name;
@@ -10,6 +10,7 @@ export class RandomIntegers {
     bytes = new Uint8Array();
     offset = 0;
     source;
+    state;
     closed = false;
     closing;
     opening;
@@ -26,38 +27,45 @@ export class RandomIntegers {
         if (this.closed)
             return Promise.reject(this.signal.reason);
         return this.opening ??= Promise.resolve().then(async () => {
-            const { fs } = this.context;
             const signal = this.signal;
             signal.throwIfAborted();
             if (this.name === undefined)
                 return;
-            const path = virtualPath(this.context.cwd, this.name);
-            await fs.access(path, 4, { signal });
-            signal.throwIfAborted();
-            if (fs.readStream)
-                this.source = ownedBytes(fs.readStream(path, { signal, chunkSize: Math.min(4096, this.maxBytes) }), signal);
-            else {
-                const maxBytes = this.maxBytes;
-                this.source = ownedBytes((async function* () {
-                    const bytes = await fs.readFile(path, { signal, ...(Number.isFinite(maxBytes) ? { maxBytes } : {}) });
-                    if (bytes.byteLength > maxBytes)
-                        throw new Diagnostic("shuf: maxInputBytes limit exceeded\n");
-                    yield bytes;
-                })(), signal);
-            }
+            this.source = new FileInput({ ...this.context, signal }, this.maxBytes);
+            await this.source.open(this.name);
             signal.throwIfAborted();
         });
     }
-    async close() {
+    close() {
         this.closed = true;
         this.controller.abort(new Error("shuf random source is closed"));
         return this.closing ??= (async () => {
-            await this.opening?.catch(() => { });
-            await this.source?.return(undefined);
+            await this.source?.close();
             this.bytes.fill(0);
             this.value = this.maximum = 0n;
         })();
     }
+    seed() {
+        if (!this.state) {
+            this.state = globalThis.crypto.getRandomValues(new Uint32Array(4));
+            if (this.state.every(value => value === 0))
+                this.state[0] = 1;
+        }
+    }
+    refill() {
+        this.seed();
+        const state = this.state;
+        const product = Math.imul(state[1], 5);
+        const result = Math.imul((product << 7) | (product >>> 25), 9) >>> 0;
+        const shifted = state[1] << 9;
+        state[2] = state[2] ^ state[0];
+        state[3] = state[3] ^ state[1];
+        state[1] = state[1] ^ state[2];
+        state[0] = state[0] ^ state[3];
+        state[2] = state[2] ^ shifted;
+        state[3] = (state[3] << 11) | (state[3] >>> 21);
+        this.bytes = Uint8Array.of(result & 255, (result >>> 8) & 255, (result >>> 16) & 255, result >>> 24);
+    }
     async byte() {
         this.signal.throwIfAborted();
         if (this.closed)
@@ -67,13 +75,13 @@ export class RandomIntegers {
                 const next = await this.source.next();
                 this.signal.throwIfAborted();
                 if (next.done)
-                    throw new Diagnostic(`shuf: ${quote(this.name)}: end of file\n`);
+                    throw new Diagnostic(`shuf: ${quote(this.name, unicodeLocale(this.context))}: end of file\n`);
                 if (next.value.byteLength > this.maxBytes)
                     throw new Diagnostic("shuf: maxInputBytes limit exceeded\n");
                 this.bytes = new Uint8Array(next.value);
             }
             else {
-                this.bytes = globalThis.crypto.getRandomValues(new Uint8Array(4096));
+                this.refill();
             }
             this.offset = 0;
             this.signal.throwIfAborted();
@@ -90,7 +98,7 @@ export class RandomIntegers {
                 throw new Error("shuf random source is closed");
             while (this.maximum < target) {
                 if (this.offset === this.bytes.length) {
-                    this.bytes = globalThis.crypto.getRandomValues(this.bytes.length === 4096 ? this.bytes : new Uint8Array(4096));
+                    this.refill();
                     this.offset = 0;
                 }
                 this.value = ((this.value << 8n) + BigInt(this.bytes[this.offset++])) & wordMax;

package/dist/safe-bash/opt-in/optional/commands/shuf/shuf.js

@@ -1,12 +1,14 @@
-import { builtInDirectContextExecutors, commandRuntimeIdentity, createBufferedOutput, getCommandArguments, isFsError, toByteSource, writeBytes, } from "@poe-platform/safe-bash/contracts";
+import { builtInDirectContextExecutors, commandRuntimeIdentity, createBufferedOutput, getCommandArguments, isFsError, writeBytes, } from "@poe-platform/safe-bash/contracts";
 import { openFileOutput } from "./filesystem-output.js";
 import { hasYieldCheckpoint, inheritYieldCheckpoint, monotonicNow, runYieldCheckpoint, yieldTurn } from "@poe-platform/safe-bash/contracts/yield";
-import { countMax, Diagnostic, fileQuote, parse, quote } from "./args.js";
-import { ownedBytes, readAllRecords, records, virtualPath } from "./input.js";
+import { countMax, Diagnostic, fileQuote, parse, quote, unicodeLocale } from "./args.js";
+import { FileInput, ownedBytes, readAllRecords, records, virtualPath } from "./input.js";
 import { settings } from "./options.js";
 import { RandomIntegers } from "./random.js";
 import { shellValueByteLength } from "@poe-platform/safe-bash/contracts/value";
 import { textOutputRequirements } from "@poe-platform/safe-bash/optional-host";
+import { publicDiagnosticMessage } from "@poe-platform/safe-bash/contracts/diagnostics";
+import { writeDiagnostic } from "@poe-platform/safe-bash/contracts/escaping";
 const encoder = new TextEncoder();
 const errors = {
     ENOENT: "No such file or directory", EACCES: "Permission denied", EPERM: "Operation not permitted",
@@ -29,7 +31,7 @@ export function createShufCommand(options = {}) {
             let output;
             let source;
             let inputSource;
-            let openingInput;
+            let fileInput;
             const inputController = new AbortController();
             const inputSignal = AbortSignal.any([context.signal, inputController.signal]);
             inheritYieldCheckpoint(context.signal, inputSignal);
@@ -42,8 +44,7 @@ export function createShufCommand(options = {}) {
                 closed = true;
                 inputController.abort(new Error("shuf input is closed"));
                 return cleanup ??= (async () => {
-                    await openingInput?.catch(() => { });
-                    const results = await Promise.allSettled([source?.return(undefined), inputSource?.return(undefined), random?.close()]);
+                    const results = await Promise.allSettled([source?.return(undefined), inputSource?.return(undefined), fileInput?.close(), random?.close()]);
                     const failed = results.find(result => result.status === "rejected");
                     if (failed?.status === "rejected")
                         throw failed.reason;
@@ -52,6 +53,7 @@ export function createShufCommand(options = {}) {
             context.registerCleanup?.(close);
             try {
                 context.signal.throwIfAborted();
+                const unicode = unicodeLocale(context);
                 const parsed = parse(context);
                 if (parsed.action) {
                     const { help, version } = await import("./usage.js");
@@ -78,38 +80,28 @@ export function createShufCommand(options = {}) {
                     }
                     size = BigInt(lines.length);
                 }
-                else if (parsed.count !== 0n && !parsed.range) {
-                    const name = parsed.operands.length ? context.args[parsed.operands[0]] : "-";
+                else if (!parsed.range && !parsed.echo && (parsed.count !== 0n || parsed.repeat)) {
+                    const name = parsed.count === 0n || !parsed.operands.length ? "-" : Array.from(getCommandArguments(context).bytes(parsed.operands[0]), byte => String.fromCharCode(byte)).join("");
                     let inputSize = Infinity;
-                    openingInput = Promise.resolve().then(async () => {
+                    {
                         inputSignal.throwIfAborted();
                         let input;
                         if (name === "-")
                             input = context.stdin;
                         else {
-                            diagnostic = fileQuote(name);
-                            const path = virtualPath(context.cwd, name);
-                            const stat = await context.fs.stat(path, { signal: inputSignal });
-                            if (stat.type === "file" && Number.isSafeInteger(stat.size) && stat.size >= 0)
+                            diagnostic = fileQuote(name, unicode);
+                            fileInput = new FileInput({ ...context, signal: inputSignal }, limits.maxInputBytes);
+                            await fileInput.open(name);
+                            const stat = fileInput.stat;
+                            if (stat?.type === "file" && Number.isSafeInteger(stat.size) && stat.size >= 0)
                                 inputSize = stat.size;
-                            inputSignal.throwIfAborted();
-                            await context.fs.access(path, 4, { signal: inputSignal });
-                            inputSignal.throwIfAborted();
-                            if (context.fs.readStream)
-                                input = context.fs.readStream(path, { signal: inputSignal });
-                            else {
-                                const bytes = await context.fs.readFile(path, { signal: inputSignal, ...(Number.isFinite(limits.maxInputBytes) ? { maxBytes: limits.maxInputBytes } : {}) });
-                                if (bytes.byteLength > limits.maxInputBytes)
-                                    throw new Diagnostic("shuf: maxInputBytes limit exceeded\n");
-                                input = toByteSource(bytes);
-                            }
+                            input = fileInput;
                         }
                         inputSource = ownedBytes(input, inputSignal);
                         inputSignal.throwIfAborted();
                         if (closed)
                             throw new Error("shuf input is closed");
-                    });
-                    await openingInput;
+                    }
                     diagnostic = "read error";
                     reservoir = !parsed.repeat && parsed.count < countMax && inputSize > 8 * 1024 * 1024;
                     if (!reservoir) {
@@ -122,10 +114,12 @@ export function createShufCommand(options = {}) {
                 }
                 random = new RandomIntegers(context, parsed.random, limits.maxInputBytes);
                 const count = parsed.repeat || parsed.count < size ? parsed.count : size;
-                diagnostic = fileQuote(parsed.random ?? "getrandom");
-                if (reservoir || parsed.repeat || count > 0n)
+                diagnostic = fileQuote(parsed.random ?? "getrandom", unicode);
+                if (reservoir && parsed.count > 0n || parsed.repeat || count > 0n)
                     await random.open();
-                diagnostic = parsed.random === undefined ? "getrandom" : `${quote(parsed.random)}: read error`;
+                if (parsed.repeat && parsed.random === undefined)
+                    random.seed();
+                diagnostic = parsed.random === undefined ? "getrandom" : `${quote(parsed.random, unicode)}: read error`;
                 if (reservoir) {
                     let seen = 0n;
                     while (seen < parsed.count) {
@@ -143,7 +137,7 @@ export function createShufCommand(options = {}) {
                     }
                     if (seen === parsed.count) {
                         while (true) {
-                            diagnostic = parsed.random === undefined ? "getrandom" : `${quote(parsed.random)}: read error`;
+                            diagnostic = parsed.random === undefined ? "getrandom" : `${quote(parsed.random, unicode)}: read error`;
                             const chosen = await random.choose(seen + 1n);
                             diagnostic = "read error";
                             const next = await source.next();
@@ -181,12 +175,13 @@ export function createShufCommand(options = {}) {
                 const streamDirect = !parsed.repeat && parsed.output === undefined && parsed.random === undefined;
                 const permutation = [];
                 const swaps = new Map();
-                diagnostic = parsed.random === undefined ? "getrandom" : `${quote(parsed.random)}: read error`;
+                const sparse = ahead > 0n && (size > 0xffffffffn || size >= 128n * 1024n && size / ahead >= 32n);
+                diagnostic = parsed.random === undefined ? "getrandom" : `${quote(parsed.random, unicode)}: read error`;
                 const useSyncRandom = parsed.random === undefined;
                 if (!parsed.repeat && !streamDirect) {
                     for (let index = 0n; index < ahead; index++) {
                         const chosen = index + (useSyncRandom ? random.chooseSync(size - index) : await random.choose(size - index));
-                        permutation.push(swaps.get(chosen) ?? chosen);
+                        permutation.push(sparse && chosen === index ? index : swaps.get(chosen) ?? chosen);
                         swaps.set(chosen, swaps.get(index) ?? index);
                         swaps.delete(index);
                         if (index % 1024n === 1023n) {
@@ -202,7 +197,7 @@ export function createShufCommand(options = {}) {
                     }
                 }
                 if (parsed.output !== undefined) {
-                    diagnostic = fileQuote(parsed.output);
+                    diagnostic = fileQuote(parsed.output, unicode);
                     openingRootOutput = parsed.output.length > 0 && Array.from(parsed.output).every(character => character === "/");
                     output = await openFileOutput(context, virtualPath(context.cwd, parsed.output), "w");
                     openingRootOutput = false;
@@ -212,14 +207,14 @@ export function createShufCommand(options = {}) {
                 const sink = createBufferedOutput(output?.sink ?? context.stdout, context.signal);
                 for (let index = 0n; index < ahead; index++) {
                     context.signal.throwIfAborted();
-                    diagnostic = parsed.random === undefined ? "getrandom" : `${quote(parsed.random)}: read error`;
+                    diagnostic = parsed.random === undefined ? "getrandom" : `${quote(parsed.random, unicode)}: read error`;
                     let chosen;
                     if (parsed.repeat) {
                         chosen = useSyncRandom ? random.chooseSync(size) : await random.choose(size);
                     }
                     else if (streamDirect) {
                         const pick = index + (useSyncRandom ? random.chooseSync(size - index) : await random.choose(size - index));
-                        chosen = swaps.get(pick) ?? pick;
+                        chosen = sparse && pick === index ? index : swaps.get(pick) ?? pick;
                         swaps.set(pick, swaps.get(index) ?? index);
                         swaps.delete(index);
                     }
@@ -229,6 +224,8 @@ export function createShufCommand(options = {}) {
                     const line = parsed.range ? encoder.encode(`${parsed.range.low + chosen}${parsed.delimiter === 0 ? "\0" : "\n"}`) : lines[Number(chosen)];
                     diagnostic = "write error";
                     await sink.write(line);
+                    if (parsed.repeat && parsed.random !== undefined)
+                        await sink.flush();
                     if (index % 256n === 255n) {
                         if (++yieldChecks % 16 === 0 || hasYieldCheckpoint(context.signal) || monotonicNow() - lastYield >= 25) {
                             await yieldTurn(context.signal);
@@ -251,10 +248,15 @@ export function createShufCommand(options = {}) {
                 if (output)
                     await output.abort(error);
                 context.signal.throwIfAborted();
+                inputSignal.throwIfAborted();
                 if (isFsError(error) && error.code === "EPIPE" && diagnostic === "write error")
                     return { exitCode: 141 };
-                if (!(error instanceof Diagnostic) && !isFsError(error))
-                    throw error;
+                if (!(error instanceof Diagnostic) && !isFsError(error)) {
+                    if ((diagnostic === "write error" || diagnostic === "getrandom") && error instanceof Error)
+                        throw error;
+                    await writeDiagnostic(context.stderr, `${context.command}: ${publicDiagnosticMessage(error, context.onInternalError)}\n`, context.signal);
+                    return { exitCode: 1 };
+                }
                 const message = error instanceof Diagnostic ? error.message : `shuf: ${diagnostic}: ${openingRootOutput && error.code === "EISDIR" ? "File exists" : errors[error.code] ?? error.code}\n`;
                 await writeBytes(context.stderr, error instanceof Diagnostic && error.bytes ? error.bytes : encoder.encode(message), context.signal);
                 return { exitCode: 1 };

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

@@ -672,7 +672,7 @@ export declare class Runtime {
     private ifsSeparator;
     substring(part: Extract<WordPart, {
         kind: "variable";
-    }>, value: string | undefined, state: State, io: IO): Promise<string>;
+    }>, value: ShellValue | undefined, state: State, io: IO): Promise<ShellValue>;
     private tryFastParameterPatternSync;
     parameterPattern(part: Extract<WordPart, {
         kind: "variable";

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

@@ -25377,7 +25377,7 @@ export class Runtime {
             if (part.length)
                 return this.valueLength(value ?? "", state, io);
             if (part.substring)
-                return this.substring(part, value === undefined ? undefined : shellValueText(value), state, io);
+                return this.substring(part, value, state, io);
             if (part.transform)
                 return part.transform === "a" || part.transform === "A" || part.transform === "K" || part.transform === "k" ? this.variableMetaTransform(part, state, io) : value === undefined ? "" : this.transformValue(value, part.transform, state, io);
             if (part.operator)
@@ -25870,7 +25870,7 @@ export class Runtime {
         }
         if (part.substring) {
             this.requireParameter(value, part.name, state, io, part.line);
-            return this.substring(part, value, state, io);
+            return this.substring(part, retained, state, io);
         }
         if (part.operator) {
             if (["#", "##", "%", "%%", "^", "^^", ",", ",,"].includes(part.operator) || part.operator.startsWith("/")) {
@@ -25999,10 +25999,10 @@ export class Runtime {
             const offsetExpression = await arithmetic(expression.offset);
             let bytes;
             if (byteLocale(state.variables)) {
-                scratch.reserve(shellValueByteLength(value), 0);
-                bytes = fastSharedTextEncoder.encode(value);
+                bytes = shellValueBytes(value, scratch);
             }
-            const size = BigInt(bytes?.byteLength ?? (await scanString(value, work)).count);
+            const text = shellValueText(value);
+            const size = BigInt(bytes?.byteLength ?? (await scanString(text, work)).count);
             const offset = offsetExpression.value < 0n ? size + offsetExpression.value : offsetExpression.value;
             if (offset < 0n || offset > size)
                 return "";
@@ -26017,19 +26017,13 @@ export class Runtime {
             }
             this.signal.throwIfAborted();
             if (!bytes) {
-                const start = (await scanString(value, work, 0, value.length, Number(offset))).end;
-                const finish = (await scanString(value, work, start, value.length, Number(end - offset))).end;
+                const start = (await scanString(text, work, 0, text.length, Number(offset))).end;
+                const finish = (await scanString(text, work, start, text.length, Number(end - offset))).end;
                 if (finish > start)
                     scratch.reserve((finish - start) * 2, 0);
-                return value.slice(start, finish);
-            }
-            scratch.reserve(Number(end - offset) * 2, 0);
-            try {
-                return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes.subarray(Number(offset), Number(end)));
-            }
-            catch {
-                throw new ExpansionFailure("substring expansion splits a UTF-8 character in a byte locale", line);
+                return text.slice(start, finish);
             }
+            return shellValueFromBytes(bytes.subarray(Number(offset), Number(end)), io[valueScope]);
         }
         finally {
             scratch.close();
@@ -26148,7 +26142,7 @@ export class Runtime {
             const replacementIO = part.replacement ? this.parameterOperandIO(part.replacement, state, io) : io;
             for (const [index, entry] of (part.replacement?.parts ?? []).entries()) {
                 let value = entry.kind === "text" ? entry.value : await this.part(entry, state, replacementIO, hereString);
-                if (index === 0 && entry.kind === "text" && !part.quoted && !entry.quoted && /^~(?:\/|$)/u.test(value)) {
+                if (index === 0 && entry.kind === "text" && !entry.quoted && /^~(?:\/|$)/u.test(value)) {
                     const home = state.variables.HOME ?? "~";
                     scratch.reserve((home.length + value.length - 1) * 2, 0);
                     value = home + value.slice(1);

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

@@ -4,7 +4,7 @@ import {
   ShellSyntaxError,
   cloudflareWorkerLimits,
   parseShell
-} from "./chunks/chunk-HEENNMEW.js";
+} from "./chunks/chunk-6P25QN5M.js";
 import "./chunks/chunk-AKC46AF6.js";
 import "./chunks/chunk-D2XB7XIC.js";
 import "./chunks/chunk-U5NUZPCC.js";

package/dist/safe-bash-command-shuf/args.d.ts

@@ -5,19 +5,21 @@ export declare class Diagnostic extends Error {
     readonly bytes?: Uint8Array | undefined;
     constructor(message: string, bytes?: Uint8Array | undefined);
 }
-export declare function quote(value: string | Uint8Array): string;
-export declare function fileQuote(value: string): string;
+export declare function unicodeLocale(context: CommandContext): boolean;
+export declare function quote(value: string | Uint8Array, unicode?: boolean): string;
+export declare function fileQuote(value: string, unicode?: boolean): string;
 export declare function parse(context: CommandContext): {
     echo: boolean;
     repeat: boolean;
     delimiter: number;
     count: bigint;
+    hasCount: boolean;
+    operands: number[];
     range: {
         low: bigint;
         size: bigint;
     } | undefined;
     output: string | undefined;
     random: string | undefined;
-    action: "help" | "version" | undefined;
-    operands: number[];
+    action: string | undefined;
 };