@poe-platform/safe-bash 0.1.792 → 0.1.794

package/dist/safe-bash-command-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-command-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-command-shuf/random.js

@@ -1,6 +1,6 @@
 import { yieldTurn } from "../safe-bash-contracts/yield.js";
-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-command-shuf/shuf.js

@@ -1,12 +1,14 @@
-import { builtInDirectContextExecutors, commandRuntimeIdentity, createBufferedOutput, getCommandArguments, isFsError, toByteSource, writeBytes, } from "../safe-bash-contracts/index.js";
+import { builtInDirectContextExecutors, commandRuntimeIdentity, createBufferedOutput, getCommandArguments, isFsError, writeBytes, } from "../safe-bash-contracts/index.js";
 import { openFileOutput } from "./filesystem-output.js";
 import { hasYieldCheckpoint, inheritYieldCheckpoint, monotonicNow, runYieldCheckpoint, yieldTurn } from "../safe-bash-contracts/yield.js";
-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 "../safe-bash-contracts/value.js";
 import { textOutputRequirements } from "../safe-bash-io-engine/portable-requirements.js";
+import { publicDiagnosticMessage } from "../safe-bash-contracts/diagnostics.js";
+import { writeDiagnostic } from "../safe-bash-contracts/escaping.js";
 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-command-sqlite3/btree.d.ts

@@ -1,4 +1,4 @@
-export type SqlValue = null | number | bigint | Number | string | Uint8Array;
+export type SqlValue = null | number | bigint | Number | String | string | Uint8Array;
 export interface StoredTableMeta {
     type: "table" | "index" | "view" | "trigger";
     name: string;

package/dist/safe-bash-command-sqlite3/engine.d.ts

@@ -220,7 +220,6 @@ export declare class SqliteDatabase {
     private evalExprWithAggAndWindow;
     private evalExprWithAgg;
     private evalAggregateFunction;
-    private sqlValToJsJson;
     private validateColumns;
     private lookupColInRow;
     private evalScalarSql;
@@ -233,4 +232,5 @@ export declare class SqliteDatabase {
     private applyBinary;
     private applyCast;
     private evalScalarFunction;
+    private evalScalarFunctionValue;
 }