@poe-platform/safe-bash 0.1.806 → 0.1.807

package/dist/safe-bash-command-rsvg-convert/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-command-rsvg-convert/index.d.ts

@@ -0,0 +1,13 @@
+import { type CommandDefinition, type VirtualShellPlugin } from "../safe-bash-contracts/index.js";
+export interface RsvgConvertLimits {
+    readonly maxInputBytes: number;
+    readonly maxNodes: number;
+    readonly maxPixels: number;
+}
+export interface RsvgConvertCommandsOptions {
+    readonly limits?: Partial<RsvgConvertLimits>;
+    readonly replace?: boolean;
+}
+export declare function createRsvgConvertCommand(options?: RsvgConvertCommandsOptions): CommandDefinition;
+export declare function createRsvgConvertCommands(options?: RsvgConvertCommandsOptions): readonly CommandDefinition[];
+export declare function rsvgConvertCommands(options?: RsvgConvertCommandsOptions): VirtualShellPlugin;

package/dist/safe-bash-command-rsvg-convert/index.js

@@ -0,0 +1,84 @@
+import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
+
+// packages/safe-bash-command-rsvg-convert/src/index.ts
+import { commandRuntimeIdentity, getCommandArguments } from "../safe-bash-contracts/index.js";
+import { InputByteBudget, collectBytes, writeBytes } from "../safe-bash-contracts/io.js";
+import { resolvePath } from "../safe-bash-contracts/path.js";
+import { createOutputOperation } from "../safe-bash-contracts/output.js";
+import { writeFileOutput } from "../safe-bash-contracts/filesystem-output-budget.js";
+import { inheritYieldCheckpoint } from "../safe-bash-contracts/yield.js";
+function createRsvgConvertCommand(options = {}) {
+  const maxInputBytes = InputByteBudget.limit(options.limits?.maxInputBytes ?? 4 * 1024 * 1024);
+  const maxNodes = InputByteBudget.limit(options.limits?.maxNodes ?? 1e4);
+  const maxPixels = InputByteBudget.limit(options.limits?.maxPixels ?? 16e6);
+  return { name: "rsvg-convert", runtimeIdentity: commandRuntimeIdentity, async execute(context) {
+    return new InputByteBudget(maxInputBytes, context.inputBudget).run(context, async (context2) => {
+      const operation = createOutputOperation(context2, { write: async () => {
+      } });
+      inheritYieldCheckpoint(context2.signal, operation.signal);
+      try {
+        const args = getCommandArguments(context2).args;
+        let format = "png";
+        let output;
+        let input;
+        let positional = false;
+        const diagnostic = async (message) => {
+          await writeBytes(context2.stderr, new TextEncoder().encode(`rsvg-convert: ${message}
+`), operation.signal);
+          return { exitCode: 1 };
+        };
+        for (let i = 0; i < args.length; i++) {
+          const arg = args[i];
+          if (!positional && arg === "--") {
+            positional = true;
+            continue;
+          }
+          if (!positional && arg === "--help") {
+            await writeBytes(operation.child(context2.stdout).output, new TextEncoder().encode("Usage: rsvg-convert [-f pdf|png] [-o OUTPUT] [INPUT]\n"), operation.signal);
+            return { exitCode: 0 };
+          }
+          if (!positional && (arg === "-f" || arg === "--format")) {
+            format = args[++i] ?? "";
+            continue;
+          }
+          if (!positional && (arg === "-o" || arg === "--output")) {
+            output = args[++i];
+            if (!output) return diagnostic("missing output path");
+            continue;
+          }
+          if (!positional && arg.startsWith("-") && arg !== "-") return diagnostic(`unsupported option ${arg}`);
+          if (input !== void 0) return diagnostic("expected at most one input");
+          input = arg;
+        }
+        if (format !== "pdf" && format !== "png") return diagnostic(`unsupported format ${format}`);
+        const bytes = !input || input === "-" ? await collectBytes(context2.stdin, { signal: operation.signal }) : await context2.fs.readFile(resolvePath(context2.cwd, input), { signal: operation.signal });
+        let rendered;
+        try {
+          rendered = await (await import("../safe-bash-svg-engine/index.js")).renderSvgDocument(new TextDecoder().decode(bytes), format, { signal: operation.signal, maxNodes, maxPixels });
+        } catch (error) {
+          operation.signal.throwIfAborted();
+          return diagnostic(error instanceof Error ? error.message : "invalid SVG");
+        }
+        if (output && output !== "-") await writeFileOutput(context2, rendered, (data) => context2.fs.writeFile(resolvePath(context2.cwd, output), data, { signal: operation.signal }));
+        else await writeBytes(operation.child(context2.stdout).output, rendered, operation.signal);
+        return { exitCode: 0 };
+      } finally {
+        await operation.close();
+      }
+    });
+  } };
+}
+function createRsvgConvertCommands(options = {}) {
+  return [createRsvgConvertCommand(options)];
+}
+function rsvgConvertCommands(options = {}) {
+  const commands = createRsvgConvertCommands(options);
+  return { name: "rsvg-convert", setup(host) {
+    for (const command of commands) host.commands.register(command, { replace: options.replace ?? false });
+  } };
+}
+export {
+  createRsvgConvertCommand,
+  createRsvgConvertCommands,
+  rsvgConvertCommands
+};

package/dist/safe-bash-command-safejs/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-command-safejs/filesystem.d.ts

@@ -0,0 +1,5 @@
+import type { FileSystem, NodeFsBridgeOptions } from "@poe-platform/safe-fs";
+export type { NodeFsBridgeFileSystem, NodeFsBridgeOptions, NodeFsImplementation as SafeJsFsImplementation } from "@poe-platform/safe-fs";
+export declare function makeSafeJsFsModule<Module>(makeFsModule: (options: {
+    adapter: FileSystem;
+} & NodeFsBridgeOptions) => Module, fs: FileSystem, options?: NodeFsBridgeOptions): Module;

package/dist/safe-bash-command-safejs/filesystem.js

@@ -0,0 +1,7 @@
+import {
+  makeSafeJsFsModule
+} from "../safe-bash/command-chunks/chunk-YFZ6FPIC.js";
+import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
+export {
+  makeSafeJsFsModule
+};

package/dist/safe-bash-command-safejs/index.d.ts

@@ -0,0 +1,4 @@
+export { createSafeJsCommands } from "./runtime.js";
+export type { SafeJsCommandDialect } from "./runtime.js";
+export { defaultSafeJsLimits } from "./options.js";
+export * from "./types.js";

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

@@ -0,0 +1,19 @@
+import {
+  createSafeJsCommands
+} from "../safe-bash/command-chunks/chunk-7SOE7XIS.js";
+import "../safe-bash/command-chunks/chunk-WHNYT34N.js";
+import {
+  defaultSafeJsLimits
+} from "../safe-bash/command-chunks/chunk-B4UWZCQR.js";
+import "../safe-bash/command-chunks/chunk-KUGV3SSL.js";
+import {
+  SafeJsCommandLimitError
+} from "../safe-bash/command-chunks/chunk-ABH5FMMA.js";
+import "../safe-bash/command-chunks/chunk-YFZ6FPIC.js";
+import "../safe-bash/command-chunks/chunk-PQOAM5SC.js";
+import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
+export {
+  SafeJsCommandLimitError,
+  createSafeJsCommands,
+  defaultSafeJsLimits
+};

package/dist/safe-bash-command-safejs/io.d.ts

@@ -0,0 +1,35 @@
+import { type ByteSink, type ByteSource } from "../safe-bash-contracts/index.js";
+export declare class GuestInput {
+    private readonly limit;
+    private readonly signal;
+    private readonly fail;
+    private readonly resource;
+    private readonly iterator;
+    private pending;
+    private consumed;
+    private pulls;
+    private queue;
+    constructor(source: ByteSource, limit: number, signal: AbortSignal, fail: (error: unknown) => void, resource?: "maxSourceBytes" | "maxInputBytes");
+    private take;
+    private serialize;
+    readBytes(size?: unknown): Promise<number[] | null>;
+    readText(): Promise<string>;
+    close(): Promise<void>;
+}
+export declare class GuestOutput {
+    private readonly stdout;
+    private readonly stderr;
+    private readonly limit;
+    private readonly signal;
+    private readonly fail;
+    private queue;
+    private produced;
+    stderrFailed: boolean;
+    constructor(stdout: ByteSink, stderr: ByteSink, limit: number, signal: AbortSignal, fail: (error: unknown) => void);
+    private enqueue;
+    text(value: unknown, stderr?: boolean): Promise<void>;
+    bytes(value: unknown, stderr?: boolean): Promise<void>;
+    console(args: readonly unknown[], stderr: boolean): void;
+    result(value: unknown): Promise<void>;
+    drain(): Promise<void>;
+}

package/dist/safe-bash-command-safejs/io.js

@@ -0,0 +1,12 @@
+import {
+  GuestInput,
+  GuestOutput
+} from "../safe-bash/command-chunks/chunk-WHNYT34N.js";
+import "../safe-bash/command-chunks/chunk-KUGV3SSL.js";
+import "../safe-bash/command-chunks/chunk-ABH5FMMA.js";
+import "../safe-bash/command-chunks/chunk-PQOAM5SC.js";
+import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
+export {
+  GuestInput,
+  GuestOutput
+};

package/dist/safe-bash-command-safejs/options.d.ts

@@ -0,0 +1,22 @@
+import type { SafeJsCommandLimits } from "./types.js";
+/** No quotas are enabled by default. */
+export declare const defaultSafeJsLimits: Readonly<Partial<SafeJsCommandLimits>>;
+export declare function commandLimits(options?: Partial<SafeJsCommandLimits>): SafeJsCommandLimits;
+export interface Invocation {
+    readonly source?: string;
+    readonly file: string;
+    readonly args: readonly string[];
+    readonly print: boolean;
+    readonly help: boolean;
+    readonly inputType?: "module" | "commonjs";
+    readonly check?: boolean;
+    readonly preloads?: readonly string[];
+    readonly sourceMaps?: boolean;
+    readonly output?: string;
+    readonly nodeOptions?: readonly string[];
+    readonly envFiles?: readonly {
+        path: string;
+        optional: boolean;
+    }[];
+}
+export declare function invocation(args: readonly string[]): Invocation;

package/dist/safe-bash-command-safejs/options.js

@@ -0,0 +1,11 @@
+import {
+  commandLimits,
+  defaultSafeJsLimits,
+  invocation
+} from "../safe-bash/command-chunks/chunk-B4UWZCQR.js";
+import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
+export {
+  commandLimits,
+  defaultSafeJsLimits,
+  invocation
+};

package/dist/safe-bash-command-safejs/render.d.ts

@@ -0,0 +1 @@
+export declare function renderOutput(values: readonly unknown[], limit: number, fail: (error: unknown) => void): string;

package/dist/safe-bash-command-safejs/render.js

@@ -0,0 +1,9 @@
+import {
+  renderOutput
+} from "../safe-bash/command-chunks/chunk-KUGV3SSL.js";
+import "../safe-bash/command-chunks/chunk-ABH5FMMA.js";
+import "../safe-bash/command-chunks/chunk-PQOAM5SC.js";
+import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
+export {
+  renderOutput
+};

package/dist/safe-bash-command-safejs/runtime.d.ts

@@ -0,0 +1,25 @@
+import { type CommandDefinition } from "../safe-bash-contracts/index.js";
+import { type Invocation } from "./options.js";
+import { type SafeJsCommandsOptions, type SafeJsModule } from "./types.js";
+export interface SafeJsCommandDialect {
+    readonly name: string;
+    readonly description: string;
+    readonly help: string;
+    readonly invocation: (args: readonly string[]) => Invocation;
+    readonly transformSource?: (source: string, selected: Invocation) => string;
+    readonly prepare?: (source: string, selected: Invocation, modules: Record<string, SafeJsModule>, lifecycle: {
+        readonly fs: import("../safe-bash-contracts/filesystem.js").FileSystem;
+        readonly signal: AbortSignal;
+        readonly fail: (error: unknown) => void;
+        readonly sourceBytes: number;
+        readonly readSource: (filename: string, maxBytes?: number) => Promise<string>;
+    }) => Promise<SafeJsPreparedProgram> | SafeJsPreparedProgram;
+}
+interface SafeJsPreparedProgram {
+    readonly source: string;
+    readonly importSpecifiers?: readonly string[];
+    readonly bindings: SafeJsModule;
+    readonly sourceLocation?: import("./types.js").SafeJsRunOptions<unknown>["sourceLocation"];
+}
+export declare function createSafeJsCommands<Budget = unknown>(options: SafeJsCommandsOptions<Budget>, dialect: SafeJsCommandDialect): readonly CommandDefinition[];
+export {};

package/dist/safe-bash-command-safejs/runtime.js

@@ -0,0 +1,13 @@
+import {
+  createSafeJsCommands
+} from "../safe-bash/command-chunks/chunk-7SOE7XIS.js";
+import "../safe-bash/command-chunks/chunk-WHNYT34N.js";
+import "../safe-bash/command-chunks/chunk-B4UWZCQR.js";
+import "../safe-bash/command-chunks/chunk-KUGV3SSL.js";
+import "../safe-bash/command-chunks/chunk-ABH5FMMA.js";
+import "../safe-bash/command-chunks/chunk-YFZ6FPIC.js";
+import "../safe-bash/command-chunks/chunk-PQOAM5SC.js";
+import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
+export {
+  createSafeJsCommands
+};

package/dist/safe-bash-command-safejs/types.d.ts

@@ -0,0 +1,85 @@
+import type { FileSystem, FsBridgeOptions } from "@poe-platform/safe-fs/core";
+export type SafeJsHostFunction = {
+    call(...args: readonly unknown[]): unknown;
+}["call"];
+export type SafeJsHostValue = string | number | boolean | null | undefined | SafeJsHostFunction | readonly SafeJsHostValue[] | {
+    readonly [key: string]: SafeJsHostValue;
+};
+export type SafeJsModule = Record<string, SafeJsHostValue>;
+export interface SafeJsBudgetOptions {
+    readonly maxSteps?: number;
+    readonly deadline?: number;
+    readonly maxCallDepth?: number;
+    readonly stringLength?: number;
+    readonly arrayLength?: number;
+    readonly dataSize?: number;
+}
+export interface SafeJsRunOptions<Budget> {
+    /** Explicitly admitted runtime options; budgets and host capabilities remain authoritative. */
+    readonly nodeOptions?: readonly string[];
+    readonly importSpecifiers?: readonly string[];
+    readonly bindings?: SafeJsModule;
+    readonly budget: Budget;
+    readonly filename: string;
+    /** Maps one-based generated guest stack positions to original source locations. */
+    readonly sourceLocation?: (position: {
+        line: number;
+        column: number;
+    }) => {
+        filename: string;
+        line: number;
+        column: number;
+    } | undefined;
+    readonly modules: Record<string, SafeJsModule>;
+    readonly signal: AbortSignal;
+    readonly sink: {
+        log(...args: unknown[]): void;
+        error(...args: unknown[]): void;
+    };
+}
+export type SafeJsRunResult = {
+    readonly ok: true;
+    readonly returnValue?: unknown;
+} | {
+    readonly ok: false;
+    readonly error: unknown;
+};
+export interface SafeJsRuntime<Budget> {
+    /** Trusted implemented semantics and identity, never inferred from host Node. */
+    readonly node?: {
+        readonly version?: string;
+        readonly options?: Readonly<Record<string, "boolean" | "value">>;
+    };
+    /** Parse the complete source without evaluating it or resolving imports; throw on invalid syntax. */
+    readonly parseSourceModule?: (source: string, filename: string) => unknown;
+    readonly run: (source: string, options: SafeJsRunOptions<Budget>) => Promise<SafeJsRunResult>;
+    readonly createBudget: (options: SafeJsBudgetOptions) => Budget;
+    readonly makeFsModule: (options: {
+        adapter: FileSystem;
+    } & Pick<FsBridgeOptions, "cwd" | "signal">) => SafeJsModule;
+    readonly declareHostOperation: <Operation extends SafeJsHostFunction>(operation: Operation, policy: "read-side-effect", options?: {
+        readonly awaitResult?: boolean;
+        readonly callbackScheduling?: "after-prefix";
+    }) => Operation;
+}
+export interface SafeJsCommandLimits {
+    readonly maxSourceBytes: number;
+    readonly maxInputBytes: number;
+    readonly maxOutputBytes: number;
+    readonly timeoutMs: number;
+    readonly maxSteps: number;
+    readonly maxCallDepth: number;
+    readonly stringLength: number;
+    readonly arrayLength: number;
+    readonly dataSize: number;
+}
+export interface SafeJsCommandsOptions<Budget = unknown> {
+    readonly runtime?: SafeJsRuntime<Budget>;
+    readonly limits?: Partial<SafeJsCommandLimits>;
+    readonly replace?: boolean;
+}
+export declare class SafeJsCommandLimitError extends Error {
+    readonly resource: keyof SafeJsCommandLimits;
+    readonly code = "SAFEJS_LIMIT";
+    constructor(resource: keyof SafeJsCommandLimits);
+}

package/dist/safe-bash-command-safejs/types.js

@@ -0,0 +1,7 @@
+import {
+  SafeJsCommandLimitError
+} from "../safe-bash/command-chunks/chunk-ABH5FMMA.js";
+import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
+export {
+  SafeJsCommandLimitError
+};

package/dist/safe-bash-command-safejs/values.d.ts

@@ -0,0 +1,7 @@
+export declare function record(value: unknown, name: string): Record<string, unknown>;
+export declare function onlyKeys(value: Record<string, unknown>, allowed: readonly string[]): void;
+export declare function stringValue(value: unknown, name: string): string;
+export declare function booleanValue(value: unknown, fallback?: boolean): boolean;
+export declare function abortError(): Error;
+export declare function checkSignal(signal: AbortSignal | undefined): void;
+export declare function withSignal<Value>(signal: AbortSignal | undefined, operation: () => Promise<Value>): Promise<Value>;

package/dist/safe-bash-command-safejs/values.js

@@ -0,0 +1,19 @@
+import {
+  abortError,
+  booleanValue,
+  checkSignal,
+  onlyKeys,
+  record,
+  stringValue,
+  withSignal
+} from "../safe-bash/command-chunks/chunk-PQOAM5SC.js";
+import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
+export {
+  abortError,
+  booleanValue,
+  checkSignal,
+  onlyKeys,
+  record,
+  stringValue,
+  withSignal
+};

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

@@ -1,17 +1,3 @@
-import "../safe-bash/command-chunks/chunk-3SVT5VB7.js";
-import {
-  computeImageStatsSteps,
-  decodeImage,
-  encodeImage,
-  extendImageSteps,
-  extractImageSteps,
-  flipImageSteps,
-  flopImageSteps,
-  parseColor,
-  readImageMetadata,
-  resizeImageSteps,
-  rotateImageSteps
-} from "../safe-bash/command-chunks/chunk-CVKW2YIC.js";
 import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
 
 // packages/safe-bash-command-sips/src/index.ts
@@ -116,6 +102,7 @@ import {
 } from "../safe-bash-contracts/command.js";
 import { writeBytes } from "../safe-bash-contracts/io.js";
 import { createOutputOperation } from "../safe-bash-contracts/output.js";
+import { decodeImage, encodeImage, parseColor, readImageMetadata, computeImageStatsSteps, extendImageSteps, extractImageSteps, flipImageSteps, flopImageSteps, resizeImageSteps, rotateImageSteps } from "../image-ast/portable.js";
 function escapeXml(value) {
   return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
 }