@poe-platform/safe-bash 0.1.802 → 0.1.804

package/dist/safe-bash-line-ending-engine/io.js

@@ -1,289 +1,12 @@
-import { LineEndingError } from "./internal.js";
-const typedArrayPrototype = Object.getPrototypeOf(Uint8Array.prototype);
-const viewBuffer = Object.getOwnPropertyDescriptor(typedArrayPrototype, "buffer").get;
-const viewOffset = Object.getOwnPropertyDescriptor(typedArrayPrototype, "byteOffset").get;
-const viewLength = Object.getOwnPropertyDescriptor(typedArrayPrototype, "byteLength").get;
-export class Lifecycle {
-    budget;
-    captured;
-    caller;
-    admission;
-    pending = new Set();
-    cleanups = [];
-    closing;
-    diagnosticDestination;
-    diagnosticCancellation;
-    constructor(budget, output, captured, caller, admission) {
-        this.budget = budget;
-        this.captured = captured;
-        this.caller = caller;
-        this.admission = admission;
-        output.registerCleanup(() => this.close());
-    }
-    assertOpen() { this.budget.assertOpen(); if (this.closing)
-        throw new LineEndingError("command is closed"); }
-    assertDiagnosticOpen() {
-        this.caller.throwIfAborted();
-        const consumer = this.diagnosticDestination?.consumer;
-        if (consumer?.aborted) {
-            this.diagnosticCancellation = { reason: consumer.reason };
-            consumer.throwIfAborted();
-        }
-    }
-    cleanup(action) { this.assertOpen(); this.cleanups.push(action); }
-    async operation(action) {
-        this.assertOpen();
-        const pending = Promise.resolve().then(async () => { {
-            const s = this.budget.step();
-            if (s)
-                await s;
-        } this.assertOpen(); return action(); });
-        this.pending.add(pending);
-        try {
-            const value = await pending;
-            this.assertOpen();
-            return value;
-        }
-        finally {
-            this.pending.delete(pending);
-        }
-    }
-    close() {
-        return this.closing ??= Promise.resolve().then(async () => {
-            while (this.pending.size)
-                await Promise.allSettled([...this.pending]);
-            const failures = [];
-            for (const close of this.cleanups) {
-                try {
-                    await close();
-                }
-                catch (error) {
-                    failures.push(error);
-                }
-            }
-            if (failures.length === 1)
-                throw failures[0];
-            if (failures.length > 1)
-                throw new AggregateError(failures, "line-ending cleanup failed");
-        });
-    }
-    async stdout(bytes) {
-        await this.operation(async () => {
-            const write = this.captured.write;
-            this.assertOpen();
-            await Reflect.apply(write, this.captured, [bytes]);
-        });
-    }
-    async diagnostic(text) {
-        this.assertDiagnosticOpen();
-        if (this.closing || this.admission.closed)
-            throw new LineEndingError("command is closed");
-        this.budget.check(text.length * 3, this.budget.limits.maxDiagnosticBytes, "diagnostic buffer bytes");
-        const bytes = new TextEncoder().encode(text);
-        this.budget.emitted(bytes.length, true);
-        const pending = Promise.resolve().then(async () => {
-            this.assertDiagnosticOpen();
-            if (!this.diagnosticDestination) {
-                const sink = this.budget.context.stderr;
-                this.assertDiagnosticOpen();
-                const capability = sink.ownedOutput;
-                this.assertDiagnosticOpen();
-                const consumer = capability?.consumerClosed;
-                this.diagnosticDestination = { destination: capability ?? sink, consumer };
-            }
-            this.assertDiagnosticOpen();
-            const destination = this.diagnosticDestination.destination;
-            const write = destination.write;
-            this.assertDiagnosticOpen();
-            await Reflect.apply(write, destination, [bytes]);
-        });
-        this.pending.add(pending);
-        try {
-            await pending;
-            this.assertDiagnosticOpen();
-        }
-        finally {
-            this.pending.delete(pending);
-        }
-    }
-}
-export class Reader {
-    life;
-    iterator;
-    chunk = new Uint8Array();
-    offset = 0;
-    ended = false;
-    empties = 0;
-    snapshotBytes = 0;
-    closing;
-    constructor(life) {
-        this.life = life;
-        life.cleanup(() => this.close());
-    }
-    close() {
-        return this.closing ??= (async () => {
-            try {
-                if (!this.ended && this.iterator) {
-                    const iterator = this.iterator;
-                    const close = iterator.return;
-                    if (close)
-                        await Reflect.apply(close, iterator, []);
-                }
-            }
-            finally {
-                this.iterator = undefined;
-                this.life.budget.retain(-this.chunk.length - this.snapshotBytes);
-                this.chunk = new Uint8Array();
-                this.snapshotBytes = 0;
-            }
-        })();
-    }
-    async open(path, stat) {
-        const { context, signal, limits } = this.life.budget;
-        await this.life.operation(async () => {
-            let source;
-            let acquisitionAborted = false;
-            if (path === undefined)
-                source = context.stdin;
-            else {
-                const fs = context.fs;
-                const capabilitiesFor = fs.capabilitiesFor;
-                this.life.assertOpen();
-                const selected = capabilitiesFor ? await Reflect.apply(capabilitiesFor, fs, [path, { signal }]) : undefined;
-                this.life.assertOpen();
-                const capabilities = selected ?? fs.capabilities;
-                this.life.assertOpen();
-                const readStream = fs.readStream;
-                this.life.assertOpen();
-                const streaming = capabilities.streamingRead !== false;
-                this.life.assertOpen();
-                if (readStream && streaming) {
-                    source = Reflect.apply(readStream, fs, [path, { signal, chunkSize: limits.chunkSize === Infinity ? 16_384 : limits.chunkSize }]);
-                    acquisitionAborted = signal.aborted || this.life.admission.closed;
-                }
-                else {
-                    const maximum = Math.min(limits.maxInputBytes, Math.floor(limits.maxBufferedBytes / 3));
-                    const size = stat.size;
-                    this.life.assertOpen();
-                    this.life.budget.check(size, maximum, "buffered input bytes");
-                    this.life.budget.retain(Number.isFinite(maximum) ? maximum : size);
-                    this.snapshotBytes = Number.isFinite(maximum) ? maximum : size;
-                    const readFile = fs.readFile;
-                    this.life.assertOpen();
-                    const bytes = await Reflect.apply(readFile, fs, [path, { signal, ...(Number.isFinite(maximum) ? { maxBytes: maximum } : {}) }]);
-                    this.life.assertOpen();
-                    if (!(bytes instanceof Uint8Array))
-                        throw new TypeError("line-ending input requires bytes");
-                    this.life.budget.check(viewLength.call(bytes), maximum, "buffered input bytes");
-                    this.life.budget.retain(viewLength.call(bytes) - this.snapshotBytes);
-                    this.snapshotBytes = viewLength.call(bytes);
-                    source = { [Symbol.asyncIterator]: (async function* () { try {
-                            yield bytes;
-                        }
-                        finally {
-                            this.life.budget.retain(-this.snapshotBytes);
-                            this.snapshotBytes = 0;
-                        } }).bind(this) };
-                }
-            }
-            if (!acquisitionAborted)
-                this.life.assertOpen();
-            const factory = source[Symbol.asyncIterator];
-            if (!acquisitionAborted)
-                this.life.assertOpen();
-            this.iterator = Reflect.apply(factory, source, []);
-        });
-    }
-    get() {
-        const step = this.life.budget.step();
-        if (!step && this.offset < this.chunk.length) {
-            this.life.assertOpen();
-            return this.chunk[this.offset++];
-        }
-        return this.getSlow(step);
-    }
-    beforeRead;
-    async getSlow(step) {
-        if (step)
-            await step;
-        this.life.assertOpen();
-        while (this.offset === this.chunk.length) {
-            if (this.ended)
-                return -1;
-            await this.beforeRead?.();
-            const next = await this.life.operation(() => {
-                const iterator = this.iterator;
-                const advance = iterator.next;
-                this.life.assertOpen();
-                return Reflect.apply(advance, iterator, []);
-            });
-            this.life.budget.retain(-this.chunk.length);
-            this.chunk = new Uint8Array();
-            this.offset = 0;
-            const done = next.done;
-            this.life.assertOpen();
-            if (done) {
-                this.ended = true;
-                this.iterator = undefined;
-                return -1;
-            }
-            const value = next.value;
-            this.life.assertOpen();
-            if (!(value instanceof Uint8Array))
-                throw new TypeError("line-ending input requires bytes");
-            const buffer = viewBuffer.call(value);
-            const offset = viewOffset.call(value);
-            const length = viewLength.call(value);
-            this.life.budget.incoming(length);
-            this.life.budget.retain(length);
-            try {
-                if (viewOffset.call(value) !== offset || viewLength.call(value) < length)
-                    throw new TypeError("line-ending input extent changed during admission");
-                this.chunk = new Uint8Array(new Uint8Array(buffer, offset, length));
-            }
-            catch (error) {
-                this.life.budget.retain(-length);
-                throw error;
-            }
-            if (!this.chunk.length)
-                this.life.budget.check(++this.empties, this.life.budget.limits.maxEmptyChunks, "empty input chunks");
-        }
-        return this.chunk[this.offset++];
-    }
-}
-export class Writer {
-    life;
-    publish;
-    buffer;
-    used = 0;
-    constructor(life, publish) {
-        this.life = life;
-        this.publish = publish;
-        const { chunkSize, maxBufferedBytes } = life.budget.limits;
-        const size = Math.min(chunkSize === Infinity ? 16_384 : chunkSize, maxBufferedBytes);
-        life.budget.retain(size);
-        this.buffer = new Uint8Array(size);
-        life.cleanup(async () => { this.release(); });
-    }
-    release() { this.life.budget.retain(-this.buffer.length); this.buffer = new Uint8Array(); this.used = 0; }
-    put(byte) {
-        const step = this.life.budget.step();
-        if (step)
-            return step.then(() => this.putAfterStep(byte));
-        return this.putAfterStep(byte);
-    }
-    putAfterStep(byte) {
-        this.life.assertOpen();
-        this.life.budget.emitted(1);
-        this.buffer[this.used++] = byte;
-        if (this.used === this.buffer.length)
-            return this.flush();
-    }
-    async flush() {
-        this.life.assertOpen();
-        if (this.used) {
-            await this.publish(this.buffer.slice(0, this.used));
-            this.used = 0;
-        }
-    }
-}
+import {
+  Lifecycle,
+  Reader,
+  Writer
+} from "../safe-bash/command-chunks/chunk-Y22VXJBD.js";
+import "../safe-bash/command-chunks/chunk-TOH3OF3O.js";
+import "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+export {
+  Lifecycle,
+  Reader,
+  Writer
+};

package/dist/safe-bash-line-ending-engine/stage.js

@@ -1,160 +1,10 @@
-import { FsError } from "../safe-bash-contracts/index.js";
-import { writeFileOutput } from "../safe-bash-contracts/filesystem-output-budget.js";
-import { dirname, resolvePath, retainFileSystemCleanup } from "@poe-platform/safe-fs/core";
-import { LineEndingError, missing, sameIdentity } from "./internal.js";
-export class Files {
-    life;
-    constructor(life) {
-        this.life = life;
-    }
-    async call(select, args) {
-        return await this.life.operation(async () => {
-            const fs = this.life.budget.context.fs;
-            this.life.assertOpen();
-            const method = select(fs);
-            this.life.assertOpen();
-            return await Reflect.apply(method, fs, args);
-        });
-    }
-    async stat(path) {
-        try {
-            return await this.call(fs => fs.lstat, [path, { signal: this.life.budget.signal }]);
-        }
-        catch (error) {
-            this.life.assertOpen();
-            if (missing(error))
-                return undefined;
-            throw error;
-        }
-    }
-    path(name) {
-        const path = resolvePath(this.life.budget.context.cwd, name);
-        this.life.budget.check(path.length * 3, this.life.budget.limits.maxPathBytes, "path bytes");
-        this.life.budget.check(path.split("/").length - 1, this.life.budget.limits.maxDepth, "path depth");
-        return path;
-    }
-    async parents(path) {
-        const parents = [];
-        let current = "/";
-        for (const component of ["", ...dirname(path).split("/").filter(Boolean)]) {
-            if (component)
-                current = resolvePath(current, component);
-            const stat = await this.stat(current);
-            if (!stat)
-                throw new FsError("ENOENT", { path: current });
-            if (stat.type !== "directory" || !sameIdentity(stat, stat))
-                throw new LineEndingError("output requires stable non-symlink directory identities");
-            parents.push({ path: current, stat });
-        }
-        return parents;
-    }
-}
-export class Stage {
-    files;
-    path;
-    expected;
-    temporary = "";
-    identity;
-    created = false;
-    parents = [];
-    cleanup;
-    constructor(files, path, expected) {
-        this.files = files;
-        this.path = path;
-        this.expected = expected;
-        const { life } = files;
-        life.assertOpen();
-        this.cleanup = retainFileSystemCleanup(life.budget.context.fs, async (view) => {
-            if (!this.created || !this.identity)
-                return;
-            try {
-                for (const parent of this.parents) {
-                    const stat = await view.lstat(parent.path);
-                    if (stat.type !== "directory" || !sameIdentity(stat, parent.stat))
-                        return;
-                }
-                const stat = await view.lstat(this.temporary);
-                if (stat.type === "file" && sameIdentity(stat, this.identity))
-                    await view.rm(this.temporary);
-            }
-            catch (error) {
-                if (!missing(error))
-                    throw error;
-            }
-        }, { maxOperations: Math.min(4096, life.budget.limits.maxDepth + 4) });
-        life.cleanup(this.cleanup);
-    }
-    async open() {
-        const { life } = this.files;
-        const { signal, limits } = life.budget;
-        const capabilities = await life.operation(async () => {
-            const fs = life.budget.context.fs;
-            const query = fs.capabilitiesFor;
-            life.assertOpen();
-            const result = query ? await Reflect.apply(query, fs, [this.path, { signal, create: true }]) : fs.capabilities;
-            life.assertOpen();
-            return result;
-        });
-        if (capabilities.atomicRename !== true || capabilities.exclusiveCreate !== true || capabilities.permissions !== true || capabilities.append === false || capabilities.remove === false) {
-            throw new LineEndingError("file conversion requires atomic rename, exclusive create, permissions, append and cleanup capabilities");
-        }
-        if (this.expected === undefined && capabilities.atomicRenameNoReplace !== true) {
-            throw new LineEndingError("new destination requires atomic no-replace rename capability");
-        }
-        this.parents = await this.files.parents(this.path);
-        for (let attempt = 0; attempt < limits.maxTempAttempts; attempt++) {
-            this.temporary = resolvePath(dirname(this.path), `.line-ending-${attempt + 1}`);
-            this.files.path(this.temporary);
-            if (this.temporary === this.path || await this.files.stat(this.temporary))
-                continue;
-            try {
-                await this.files.call(fs => fs.writeFile, [this.temporary, new Uint8Array(), { signal, flag: "wx", mode: 0o600 }]);
-            }
-            catch (error) {
-                life.assertOpen();
-                if (typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST")
-                    continue;
-                throw error;
-            }
-            this.created = true;
-            this.identity = await this.files.stat(this.temporary);
-            if (!this.identity || this.identity.type !== "file" || !sameIdentity(this.identity, this.identity))
-                throw new LineEndingError("temporary file identity unavailable; unowned path is not removed");
-            return;
-        }
-        throw new LineEndingError("temporary file attempts limit exceeded");
-    }
-    async checked() {
-        for (const parent of this.parents) {
-            const stat = await this.files.stat(parent.path);
-            if (!stat || stat.type !== "directory" || !sameIdentity(stat, parent.stat))
-                throw new LineEndingError("output parent changed before mutation");
-        }
-        const stat = await this.files.stat(this.temporary);
-        if (!this.identity || !stat || stat.type !== "file" || !sameIdentity(stat, this.identity))
-            throw new LineEndingError("temporary file changed before mutation");
-    }
-    async append(bytes) {
-        await this.checked();
-        const { context, signal } = this.files.life.budget;
-        await this.files.life.operation(() => writeFileOutput({ signal, ...(context.registerCleanup ? { registerCleanup: context.registerCleanup } : {}) }, bytes, async (chunk) => { await this.files.call(fs => fs.appendFile, [this.temporary, chunk, { signal }]); }));
-    }
-    async publish(input, options) {
-        const { signal } = this.files.life.budget;
-        await this.checked();
-        if (!options.newFile && !options.allowChown && ((input.uid !== undefined && input.uid !== this.identity.uid) || (input.gid !== undefined && input.gid !== this.identity.gid))) {
-            throw new LineEndingError("filesystem cannot preserve input user/group ownership");
-        }
-        await this.files.call(fs => fs.chmod, [this.temporary, (input.mode & 0o777) & (options.newFile ? ~0o022 : 0o777), { signal }]);
-        if (options.keepDate) {
-            await this.checked();
-            await this.files.call(fs => fs.utimes, [this.temporary, Math.floor(input.atimeMs / 1000) * 1000, Math.floor(input.mtimeMs / 1000) * 1000, { signal }]);
-        }
-        await this.checked();
-        const current = await this.files.stat(this.path);
-        if (current ? !this.expected || current.type !== "file" || !sameIdentity(current, this.expected) : this.expected !== undefined)
-            throw new LineEndingError("destination changed before publication");
-        await this.files.call(fs => fs.rename, [this.temporary, this.path, { signal, noReplace: this.expected === undefined }]);
-        this.created = false;
-    }
-}
+import {
+  Files,
+  Stage
+} from "../safe-bash/command-chunks/chunk-MQREDAL6.js";
+import "../safe-bash/command-chunks/chunk-TOH3OF3O.js";
+import "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+export {
+  Files,
+  Stage
+};

package/dist/safe-bash-markdown-engine/index.js

@@ -1,9 +1,9 @@
-import {
-  parseCommonMarkInlines
-} from "../safe-bash/command-chunks/chunk-KZC5UWFF.js";
 import {
   parseCommonMarkBlocks
 } from "../safe-bash/command-chunks/chunk-MPL2466A.js";
+import {
+  parseCommonMarkInlines
+} from "../safe-bash/command-chunks/chunk-KZC5UWFF.js";
 import "../safe-bash/command-chunks/chunk-KP7AO66M.js";
 import "../safe-bash/command-chunks/chunk-KEV7C3KH.js";
 import "../safe-bash/command-chunks/chunk-O24ZDUJL.js";

package/dist/safe-bash-metadata-engine/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Poe Platform
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/safe-bash-metadata-engine/index.d.ts

@@ -0,0 +1,30 @@
+import { type CommandContext, type CommandDefinition, type CommandHandler, type FileType } from "../safe-bash-contracts/index.js";
+export interface MetadataLimits {
+    readonly maxEntries: number;
+    readonly maxDepth: number;
+    readonly maxOutputBytes: number;
+    readonly maxArgumentBytes: number;
+    readonly maxAttempts: number;
+    readonly maxArguments?: number;
+}
+export interface MetadataCommandsOptions {
+    readonly replace?: boolean;
+    readonly umask?: number;
+    readonly limits?: Partial<MetadataLimits>;
+}
+export declare function settings(options?: MetadataCommandsOptions): {
+    limits: MetadataLimits;
+    umask: number;
+};
+export declare class MetadataBudget {
+    readonly context: CommandContext;
+    readonly limits: MetadataLimits;
+    private entries;
+    private outputBytes;
+    get remainingEntries(): number;
+    constructor(context: CommandContext, limits: MetadataLimits);
+    step(depth?: number): Promise<void>;
+    output(text: string | Uint8Array): Promise<void>;
+}
+export declare function metadataCommand(name: string, handler: CommandHandler): CommandDefinition;
+export declare function permissionString(mode: number, type: FileType): string;

package/dist/safe-bash-metadata-engine/index.js

@@ -0,0 +1,82 @@
+import {
+  init_buffer
+} from "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+
+// packages/safe-bash-metadata-engine/src/index.ts
+init_buffer();
+import { byteLength } from "../safe-bash-io-engine/byte-encoding.js";
+import { yieldTurn } from "../safe-bash-contracts/yield.js";
+import { FsError, writeBytes } from "../safe-bash-contracts/index.js";
+import { diagnostic } from "../safe-bash-io-engine/internal.js";
+import { gnuInformation } from "../safe-bash-io-engine/gnu-information.js";
+function settings(options = {}) {
+  const limits = { maxEntries: Infinity, maxDepth: Infinity, maxOutputBytes: Infinity, maxArgumentBytes: Infinity, maxAttempts: Infinity, maxArguments: Infinity, ...options.limits };
+  for (const [key, value] of Object.entries(limits)) {
+    if (value !== Infinity && (!Number.isSafeInteger(value) || value < (key === "maxDepth" ? 0 : 1))) throw new RangeError(`Invalid metadata limit: ${key}`);
+  }
+  const umask = options.umask ?? 18;
+  if (!Number.isInteger(umask) || umask < 0 || umask > 511) throw new RangeError("Invalid metadata umask");
+  return { limits, umask };
+}
+var MetadataBudget = class {
+  constructor(context, limits) {
+    this.context = context;
+    this.limits = limits;
+    if (context.args.reduce((size, argument) => size + byteLength(argument), 0) > limits.maxArgumentBytes) throw new FsError("EFBIG", { message: "metadata argument limit exceeded" });
+  }
+  context;
+  limits;
+  entries = 0;
+  outputBytes = 0;
+  get remainingEntries() {
+    return this.limits.maxEntries - this.entries;
+  }
+  async step(depth = 0) {
+    this.context.signal.throwIfAborted();
+    if (++this.entries > this.limits.maxEntries || depth > this.limits.maxDepth) throw new FsError("EFBIG", { message: "metadata traversal limit exceeded" });
+    if (this.entries % 128 === 0) await yieldTurn();
+    this.context.signal.throwIfAborted();
+  }
+  async output(text) {
+    const bytes = typeof text === "string" ? new TextEncoder().encode(text) : text;
+    if (bytes.byteLength > this.limits.maxOutputBytes - this.outputBytes) throw new FsError("EFBIG", { message: "metadata output limit exceeded" });
+    this.outputBytes += bytes.byteLength;
+    await writeBytes(this.context.stdout, bytes, this.context.signal);
+  }
+};
+function metadataCommand(name, handler) {
+  return { name, async execute(context) {
+    context.signal.throwIfAborted();
+    try {
+      const infoPromise = gnuInformation(name, context);
+      if (infoPromise) {
+        const info = await infoPromise;
+        if (info) return info;
+      }
+      return await handler(context);
+    } catch (error) {
+      context.signal.throwIfAborted();
+      await diagnostic(context, error);
+      return { exitCode: 1 };
+    }
+  } };
+}
+function permissionString(mode, type) {
+  let text = type === "directory" ? "d" : type === "symlink" ? "l" : type === "character" ? "c" : "-";
+  for (const [read, write, execute, special, lower, upper] of [
+    [256, 128, 64, 2048, "s", "S"],
+    [32, 16, 8, 1024, "s", "S"],
+    [4, 2, 1, 512, "t", "T"]
+  ]) {
+    text += mode & read ? "r" : "-";
+    text += mode & write ? "w" : "-";
+    text += mode & special ? mode & execute ? lower : upper : mode & execute ? "x" : "-";
+  }
+  return text;
+}
+export {
+  MetadataBudget,
+  metadataCommand,
+  permissionString,
+  settings
+};

package/dist/safe-bash-metadata-engine/random.d.ts

@@ -0,0 +1 @@
+export declare function randomInteger(maximum: number): number;

package/dist/safe-bash-metadata-engine/random.js

@@ -0,0 +1,21 @@
+import {
+  init_buffer
+} from "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+
+// packages/safe-bash-metadata-engine/src/random.ts
+init_buffer();
+function randomInteger(maximum) {
+  const range = 4294967296;
+  if (!Number.isSafeInteger(maximum) || maximum < 1 || maximum > range) {
+    throw new RangeError("Random integer maximum must be an integer from 1 to 2^32");
+  }
+  const limit = Math.floor(range / maximum) * maximum;
+  const sample = new Uint32Array(1);
+  do {
+    globalThis.crypto.getRandomValues(sample);
+  } while (sample[0] >= limit);
+  return sample[0] % maximum;
+}
+export {
+  randomInteger
+};

package/dist/safe-bash-network-engine/args.d.ts

@@ -4,6 +4,12 @@ export interface DataArgument {
     readonly value: string;
 }
 export interface CurlArguments {
+    insecure?: boolean;
+    createDirs?: boolean;
+    cookies?: string[];
+    retryAllErrors?: boolean;
+    retryConnrefused?: boolean;
+    retryMaxTimeMs?: number;
     caFile?: string;
     etagSave?: string;
     etagCompare?: string;

package/dist/safe-bash-network-engine/args.js

@@ -4,11 +4,13 @@ import {
   parseArguments,
   validateRequestHeader,
   values
-} from "../safe-bash/command-chunks/chunk-3HHCU5YU.js";
+} from "../safe-bash/command-chunks/chunk-HK7F5SDC.js";
 import "../safe-bash/command-chunks/chunk-5XY4DTNG.js";
-import "../safe-bash/command-chunks/chunk-6KJ3LPI2.js";
+import "../safe-bash/command-chunks/chunk-6XBS5B46.js";
 import "../safe-bash/command-chunks/chunk-N4PFUSRM.js";
+import "../safe-bash/command-chunks/chunk-GOB777HR.js";
 import "../safe-bash/command-chunks/chunk-GRBWW4SG.js";
+import "../safe-bash/command-chunks/chunk-KWESKQHR.js";
 import "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
 export {
   flags,