@poe-platform/safe-bash 0.1.798 → 0.1.800

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

@@ -1,4 +1,4 @@
-import "../safe-bash/command-chunks/chunk-6BETHLXZ.js";
+import "../safe-bash/command-chunks/chunk-QJAFJP2G.js";
 import "../safe-bash/command-chunks/chunk-X6NJC3IC.js";
 import "../safe-bash/command-chunks/chunk-6X2OX6IJ.js";
 import {
@@ -84,7 +84,7 @@ import {
 } from "../safe-bash/command-chunks/chunk-2Z22PHMV.js";
 import {
   createZipCodec
-} from "../safe-bash/command-chunks/chunk-MKQVQMXO.js";
+} from "../safe-bash/command-chunks/chunk-5LU4UCBR.js";
 import {
   CodecError,
   createCompressionCodec
@@ -4894,6 +4894,7 @@ async function executeCsvpy(runtime2) {
       mode,
       retainOutput: (bytes) => runtime2.retain(bytes),
       write: (text2, channel) => runtime2.write(text2, channel),
+      writeBytes: (bytes, channel) => runtime2.writeBytes(bytes, channel),
       reader: async () => {
         const text2 = await runtime2.text(String(o.input_path));
         const dialect = {
@@ -10565,6 +10566,16 @@ var Runtime = class {
     await this.context[channel].write(bytes);
     this.step();
   }
+  async writeBytes(bytes, channel = "stdout") {
+    this.step();
+    if (bytes.byteLength > this.context.limits.maxOutputBytes - this.#output) throw new CsvkitOutputBudgetError();
+    this.#work += bytes.byteLength;
+    if (this.#work > this.context.limits.maxWork) throw new CsvkitWorkBudgetError();
+    this.#output += bytes.byteLength;
+    await this.checkpoint();
+    await this.context[channel].write(bytes);
+    this.step();
+  }
   async writeSideFile(path, texts) {
     this.step();
     const destination = virtualPath(this.context.cwd, path);
@@ -15130,6 +15141,162 @@ function createMemorySqliteFileSystem(volume, options) {
 // packages/safe-bash-command-csvkit/src/csvpy-interpreter.ts
 init_buffer();
 
+// packages/safe-bash-command-csvkit/src/default-csvpy.ts
+init_buffer();
+import { createPythonWorker } from "#csvpy-worker";
+function createDefaultCsvpyInterpreter(options = {}) {
+  return {
+    modes: ["reader", "dict", "agate"],
+    async load() {
+      throw new CsvkitBlocked("csvpy requires converted input");
+    },
+    async loadConverted(input, signal, work) {
+      signal.throwIfAborted();
+      if (input.mode === "dict" && input.settings.no_header_row) throw new CsvkitDiagnostic("TypeError: 'header' is an invalid keyword argument for this function");
+      const table = input.mode === "agate" ? await input.table() : void 0;
+      const payload = JSON.stringify({ mode: input.mode, settings: input.settings, ...table ? { table: { headers: table.headers, columns: table.columns, rows: table.rows } } : {} }, (_, value) => typeof value === "bigint" ? value.toString() : value);
+      input.retainOutput(payload.length * 4);
+      let endpoint;
+      let iterator;
+      let closing;
+      let rejectInteraction;
+      const retirement = new AbortController();
+      const activeSignal = AbortSignal.any([signal, retirement.signal]);
+      if (typeof SharedArrayBuffer !== "function") throw new CsvkitBlocked("csvpy requires shared memory");
+      const shared = new SharedArrayBuffer(65544);
+      const state = new Int32Array(shared, 0, 2);
+      const transfer = new Uint8Array(shared, 8);
+      let pendingIO = Promise.resolve();
+      const close = () => closing ??= (async () => {
+        retirement.abort(new CsvkitBlocked("csvpy session closed"));
+        rejectInteraction?.(activeSignal.reason);
+        Atomics.store(state, 0, 2);
+        Atomics.notify(state, 0);
+        await endpoint?.terminate();
+        await iterator?.return?.();
+        await pendingIO.catch(() => {
+        });
+      })();
+      return {
+        profile: "cpython-3.12-wasi-agate-1.14.2",
+        close,
+        async interact(banner, interactionSignal) {
+          const invocationSignal = AbortSignal.any([activeSignal, interactionSignal]);
+          invocationSignal.throwIfAborted();
+          const { source } = await import("../safe-bash/command-chunks/python-worker-source-TYOFJMCW.js");
+          invocationSignal.throwIfAborted();
+          endpoint = createPythonWorker(source);
+          let fragment = new Uint8Array();
+          let offset = 0;
+          let accountedWork = 0;
+          const decoder = { stdout: new TextDecoder(), stderr: new TextDecoder() };
+          const read = async (size) => {
+            while (offset === fragment.length) {
+              if (!iterator) {
+                iterator = options.stdin?.[Symbol.asyncIterator]() ?? (async function* () {
+                  while (options.terminal) {
+                    const line = await options.terminal.readLine(invocationSignal);
+                    if (line === null) return;
+                    yield new TextEncoder().encode(line.endsWith("\n") ? line : line + "\n");
+                  }
+                })()[Symbol.asyncIterator]();
+              }
+              const next = await iterator.next();
+              invocationSignal.throwIfAborted();
+              if (next.done) return 0;
+              options.admitInput?.(next.value);
+              fragment = next.value;
+              offset = 0;
+            }
+            const length = Math.min(size, fragment.length - offset);
+            transfer.set(fragment.subarray(offset, offset + length));
+            offset += length;
+            return length;
+          };
+          let reader;
+          let recordBytes = new Uint8Array();
+          let recordOffset = 0;
+          let readerLine = 0;
+          const readRecord = async (size) => {
+            if (recordOffset === recordBytes.length) {
+              reader ??= await input.reader();
+              let record;
+              try {
+                const next = reader.next();
+                if (next.done) return 0;
+                readerLine = next.value.line;
+                record = ["row", next.value.cells.map((cell2) => typeof cell2 === "number" && !Number.isFinite(cell2) ? { kind: "float", value: String(cell2) } : cell2), readerLine];
+              } catch (error) {
+                if (!(error instanceof CsvkitDiagnostic) || error instanceof CsvkitBlocked) throw error;
+                const separator = error.message.indexOf(": ");
+                const fieldError = error.message.startsWith("FieldSizeLimitError:");
+                if (fieldError) {
+                  const start = error.message.indexOf("characters on line ") + "characters on line ".length;
+                  const parsed = Number(error.message.slice(start, error.message.indexOf(".", start)));
+                  if (Number.isSafeInteger(parsed) && parsed > 0) readerLine = parsed;
+                }
+                record = [fieldError ? "field-error" : error.message.startsWith("ValueError:") ? "value-error" : "error", fieldError ? "field larger than field limit (" + String(input.settings.field_size_limit ?? Infinity) + ")" : separator < 0 ? error.message : error.message.slice(separator + 2), readerLine];
+              }
+              const text2 = JSON.stringify(record) + "\n";
+              input.retainOutput(text2.length * 4);
+              recordBytes = new TextEncoder().encode(text2);
+              recordOffset = 0;
+            }
+            const length = Math.min(size, recordBytes.length - recordOffset);
+            transfer.set(recordBytes.subarray(recordOffset, recordOffset + length));
+            recordOffset += length;
+            return length;
+          };
+          const aborted = () => {
+            rejectInteraction?.(invocationSignal.reason);
+            void close();
+          };
+          invocationSignal.addEventListener("abort", aborted, { once: true });
+          try {
+            return await new Promise((resolve, reject) => {
+              rejectInteraction = reject;
+              endpoint.onMessage((message) => {
+                pendingIO = (async () => {
+                  invocationSignal.throwIfAborted();
+                  work.consume(message.work - accountedWork);
+                  accountedWork = message.work;
+                  if (message.type === "error") throw new CsvkitBlocked(message.message);
+                  if (message.type === "done") {
+                    if (!input.writeBytes) for (const channel of ["stdout", "stderr"]) {
+                      const text2 = decoder[channel].decode();
+                      if (text2) await input.write(text2, channel);
+                    }
+                    resolve(message.exitCode);
+                    return;
+                  }
+                  const size = message.channel === "stdin" ? await read(message.size) : message.channel === "reader" ? await readRecord(message.size) : 0;
+                  if (message.channel === "stdout" || message.channel === "stderr") {
+                    const bytes = transfer.subarray(0, message.size);
+                    if (input.writeBytes) await input.writeBytes(bytes, message.channel);
+                    else {
+                      const text2 = decoder[message.channel].decode(bytes, { stream: true });
+                      if (text2) await input.write(text2, message.channel);
+                    }
+                  }
+                  invocationSignal.throwIfAborted();
+                  Atomics.store(state, 1, size);
+                  Atomics.store(state, 0, 1);
+                  Atomics.notify(state, 0);
+                })();
+                void pendingIO.catch(reject);
+              }, reject);
+              endpoint.postMessage({ shared, payload, banner, workLimit: work.limit });
+            });
+          } finally {
+            invocationSignal.removeEventListener("abort", aborted);
+            await close();
+          }
+        }
+      };
+    }
+  };
+}
+
 // packages/safe-bash-command-csvkit/src/python/readers.ts
 init_buffer();
 var rawReaderLibrary = `class Error(Exception):pass
@@ -15231,7 +15398,8 @@ class FieldSizeLimitError(Exception):
 `;
 
 // packages/safe-bash-command-csvkit/src/csvpy-interpreter.ts
-function createCsvpyInterpreter(options) {
+function createCsvpyInterpreter(options = {}) {
+  if (!("createSession" in options)) return createDefaultCsvpyInterpreter(options);
   return {
     modes: ["reader", "dict", "agate"],
     load: async () => {
@@ -15678,7 +15846,7 @@ function createCsvkitCommands(options = {}) {
           clock,
           databases: databases2,
           sqlDialects,
-          ...interpreter === void 0 ? {} : { interpreter },
+          interpreter: interpreter ?? createCsvpyInterpreter({ stdin: context.stdin, admitInput: account }),
           openMatchFile: openMatchFile ?? (async (path, settings) => {
             const resolved = virtualPath(settings.cwd, path);
             await context.fs.stat(resolved, { signal: settings.signal });

package/dist/safe-bash-command-csvkit/python-worker-browser.d.ts

@@ -0,0 +1,3 @@
+import type { Endpoint } from './python-worker-contract.js';
+export declare function createPythonWorker(source: string): Endpoint;
+//# sourceMappingURL=python-worker-browser.d.ts.map

package/dist/safe-bash-command-csvkit/python-worker-browser.js

@@ -0,0 +1,16 @@
+import { CsvkitBlocked } from './errors.js';
+export function createPythonWorker(source) {
+    if (typeof globalThis.Worker !== 'function')
+        throw new CsvkitBlocked('csvpy requires a dedicated worker');
+    const url = URL.createObjectURL(new Blob([source], { type: 'text/javascript' }));
+    let worker;
+    try {
+        worker = new Worker(url, { type: 'module' });
+    }
+    catch (error) {
+        URL.revokeObjectURL(url);
+        throw error;
+    }
+    return { postMessage: message => worker.postMessage(message), terminate() { worker.terminate(); URL.revokeObjectURL(url); }, onMessage(callback, failure) { worker.onmessage = event => callback(event.data); worker.onerror = failure; } };
+}
+//# sourceMappingURL=python-worker-browser.js.map

package/dist/safe-bash-command-csvkit/python-worker-contract.d.ts

@@ -0,0 +1,20 @@
+export interface Endpoint {
+    postMessage(message: unknown): void;
+    terminate(): void | Promise<unknown>;
+    onMessage(callback: (message: Message) => void, failure: (error: unknown) => void): void;
+}
+export type Message = {
+    type: 'io';
+    channel: 'stdin' | 'stdout' | 'stderr' | 'reader';
+    size: number;
+    work: number;
+} | {
+    type: 'done';
+    exitCode: number;
+    work: number;
+} | {
+    type: 'error';
+    message: string;
+    work: number;
+};
+//# sourceMappingURL=python-worker-contract.d.ts.map

package/dist/safe-bash-command-csvkit/python-worker-node.d.ts

@@ -0,0 +1,3 @@
+import type { Endpoint } from './python-worker-contract.js';
+export declare function createPythonWorker(source: string): Endpoint;
+//# sourceMappingURL=python-worker-node.d.ts.map

package/dist/safe-bash-command-csvkit/python-worker-node.js

@@ -0,0 +1,9 @@
+import { Worker } from 'node:worker_threads';
+import { createPythonWorker as createBrowserWorker } from './python-worker-browser.js';
+export function createPythonWorker(source) {
+    if (typeof globalThis.Worker === 'function')
+        return createBrowserWorker(source);
+    const worker = new Worker(source, { eval: true });
+    return { postMessage: message => worker.postMessage(message), terminate: () => worker.terminate(), onMessage(callback, failure) { worker.on('message', callback); worker.on('error', failure); worker.on('exit', code => failure(new Error('Python worker exited before settlement: ' + code))); } };
+}
+//# sourceMappingURL=python-worker-node.js.map

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

@@ -30,6 +30,7 @@ export declare class Runtime {
     records(path: string | null | undefined, file: LazyInput | undefined, skipped: number | undefined, table: boolean | undefined, recordLimit: number | undefined, preserveCells: true): AsyncGenerator<CsvRecord<CsvCell>>;
     admitRecord(record: CsvRecord<CsvCell>): void;
     write(text: string, channel?: "stdout" | "stderr"): Promise<void>;
+    writeBytes(bytes: Uint8Array, channel?: "stdout" | "stderr"): Promise<void>;
     writeSideFile(path: string, texts: Iterable<string>): Promise<void>;
     row(cells: readonly CsvWriteCell[], dialect?: CsvDialect, lineNumbers?: boolean): Promise<void>;
     rows(rowList: Iterable<readonly CsvWriteCell[]>, dialect?: CsvDialect, lineNumbers?: boolean): Promise<void>;

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

@@ -0,0 +1,13 @@
+import { type CommandContext, type CommandDefinition } from "../safe-bash-contracts/index.js";
+import { type CurlArguments } from "../safe-bash-network-engine/args.js";
+import { type NetworkCommandsOptions, type NetworkLimits } from "../safe-bash-network-engine/types.js";
+interface TransferProfile {
+    readonly name: string;
+    readonly help: string;
+    readonly version: string;
+    parse(context: CommandContext, limits: NetworkLimits): CurlArguments | Promise<CurlArguments>;
+    status(code: number): number;
+}
+export declare function createCurlCommand(options?: NetworkCommandsOptions): CommandDefinition;
+export declare function createTransferCommand(options: NetworkCommandsOptions, profile: TransferProfile): CommandDefinition;
+export {};

package/dist/safe-bash-command-curl/curl.js

@@ -0,0 +1,9 @@
+import {
+  createCurlCommand,
+  createTransferCommand
+} from "../safe-bash/command-chunks/chunk-STC3LEWJ.js";
+import "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+export {
+  createCurlCommand,
+  createTransferCommand
+};

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

@@ -0,0 +1,6 @@
+import type { CommandDefinition, VirtualShellPlugin } from "../safe-bash-contracts/index.js";
+import type { NetworkCommandsOptions } from "../safe-bash-network-engine/types.js";
+export type { NetworkCommandsOptions as CurlCommandsOptions, NetworkLimits as CurlLimits } from "../safe-bash-network-engine/types.js";
+export { createCurlCommand } from "./curl.js";
+export declare function createCurlCommands(options?: NetworkCommandsOptions): readonly CommandDefinition[];
+export declare function curlCommands(options?: NetworkCommandsOptions): VirtualShellPlugin;

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

@@ -0,0 +1,26 @@
+import {
+  createCurlCommand
+} from "../safe-bash/command-chunks/chunk-STC3LEWJ.js";
+import {
+  init_buffer
+} from "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-curl/src/index.ts
+init_buffer();
+function createCurlCommands(options = {}) {
+  return [createCurlCommand(options)];
+}
+function curlCommands(options = {}) {
+  const commands = createCurlCommands(options);
+  return { name: "curl-commands", setup(host) {
+    if (!options.replace) {
+      for (const command of commands) if (host.commands.has(command.name)) throw new Error(`Command already registered: ${command.name}`);
+    }
+    for (const command of commands) host.commands.register(command, { replace: options.replace ?? false });
+  } };
+}
+export {
+  createCurlCommand,
+  createCurlCommands,
+  curlCommands
+};

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

@@ -4,7 +4,7 @@ import { assertCountedFileOutput, writeFileOutputCounted } from "./filesystem-ou
 import { FsError } from "@poe-platform/safe-fs/core";
 import { writeBytes } from "../safe-bash-contracts/io.js";
 import { createOutputOperation } from "../safe-bash-contracts/output.js";
-import { hasYieldCheckpoint, monotonicNow, yieldTurn } from "../safe-bash-contracts/yield.js";
+import { yieldTurn } from "../safe-bash-contracts/yield.js";
 import { DdConverter } from "./conversions.js";
 import { errorMessage, openDdFile, writeDdOutput } from "./io.js";
 import { DdError, parseDd, quote } from "./options.js";
@@ -246,15 +246,6 @@ export function createDdCommand(options = {}) {
                 let previousShort = 0;
                 let partialRecord = 0;
                 let warned = false;
-                let lastYieldTime = monotonicNow();
-                let yieldChecks = 0;
-                const maybeYield = async () => {
-                    context.signal.throwIfAborted();
-                    if (++yieldChecks % 16 === 0 || hasYieldCheckpoint(context.signal) || monotonicNow() - lastYieldTime >= 16) {
-                        await yieldTurn(context.signal);
-                        lastYieldTime = monotonicNow();
-                    }
-                };
                 const read = async (size) => {
                     context.signal.throwIfAborted();
                     if (++readOperations > limits.maxReadOperations)
@@ -298,7 +289,7 @@ export function createDdCommand(options = {}) {
                             skipRecords--;
                         else
                             skipRemainder = 0n;
-                        await maybeYield();
+                        await yieldTurn(context.signal);
                     }
                     if (skipped < skipOffset && plan.status !== "none")
                         await diagnostic(`${quote(plan.input ?? "standard input")}: cannot skip to specified offset`);
@@ -360,7 +351,7 @@ export function createDdCommand(options = {}) {
                                 report.stats.outputPartial++;
                         }
                     }
-                    await maybeYield();
+                    await yieldTurn(context.signal);
                 };
                 const outputBuffer = new Uint8Array(copying && plan.twoBuffers ? obs : 0);
                 let used = 0;
@@ -450,7 +441,7 @@ export function createDdCommand(options = {}) {
                         await converter.push(chunk);
                     else
                         await emit(chunk);
-                    await maybeYield();
+                    await yieldTurn(context.signal);
                 }
                 await converter?.finish();
                 if (used) {

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

@@ -0,0 +1,10 @@
+import { type DisplayOptions } from "./diff-output.js";
+import type { Budget } from "../safe-bash-diff-engine/shared.js";
+export interface Edit {
+    readonly kind: " " | "+" | "-";
+    readonly line: string;
+    readonly newLine?: string;
+    readonly ignored?: boolean;
+}
+export declare function normal(changes: readonly Edit[], budget: Budget, append: (text: string) => void, options?: DisplayOptions): Promise<void>;
+export declare function contextual(changes: readonly Edit[], format: "unified" | "context", oldLabel: string, newLabel: string, context: number, budget: Budget, append: (text: string) => void, options?: DisplayOptions, heading?: (position: number) => Promise<string>): Promise<void>;

package/dist/safe-bash-command-diff/diff-format.js

@@ -0,0 +1,10 @@
+import {
+  contextual,
+  normal
+} from "../safe-bash/command-chunks/chunk-Y5INTD6S.js";
+import "../safe-bash/command-chunks/chunk-6F4XCVON.js";
+import "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+export {
+  contextual,
+  normal
+};

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

@@ -0,0 +1,38 @@
+import type { DisplayOptions } from "./diff-output.js";
+import { Pattern } from "../safe-bash-regex-engine/text/regex.js";
+export interface DiffFlags extends DisplayOptions {
+    format: "normal" | "unified" | "context" | "side" | "ed" | "rcs" | "ifdef";
+    whitespace: "exact" | "change" | "all";
+    context: number;
+    brief: boolean;
+    recursive: boolean;
+    newFile: boolean;
+    unidirectionalNewFile: boolean;
+    stripTrailingCr: boolean;
+    ignoreFileNameCase: boolean;
+    noDereference?: boolean;
+    fromFile?: string;
+    toFile?: string;
+    labels: string[];
+    files: string[];
+    optionArgs: string[];
+    ignoreCase: boolean;
+    ignoreBlank: boolean;
+    ignoreTrailing: boolean;
+    ignoreTabs: boolean;
+    ignorePatterns: Pattern[];
+    functions: Pattern[];
+    reportSame: boolean;
+    text: boolean;
+    paginate: boolean;
+    excludes: {
+        pattern: string;
+        ignoreCase: boolean;
+    }[];
+    excludeFiles: {
+        path: string;
+        ignoreCase: boolean;
+    }[];
+    startingFile?: string;
+}
+export declare function flags(args: readonly string[]): DiffFlags;

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

@@ -0,0 +1,7 @@
+import {
+  flags
+} from "../safe-bash/command-chunks/chunk-UG7SMZFF.js";
+import "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+export {
+  flags
+};

package/dist/safe-bash-command-diff/diff-output.d.ts

@@ -0,0 +1,20 @@
+import type { Edit } from "./diff-format.js";
+import { type Budget } from "../safe-bash-diff-engine/shared.js";
+export interface DisplayOptions {
+    color?: boolean;
+    width: number;
+    expand: boolean;
+    initialTab: boolean;
+    leftColumn: boolean;
+    suppressCommon: boolean;
+    symbol: string;
+}
+export declare function colorText(text: string, code: 1 | 31 | 32 | 36, options?: DisplayOptions): string;
+/** GNU C-locale filename quoting, also used for labels in directory sections. */
+export declare function quoteDiffName(name: string): string;
+/** GNU shell-style quoting for the original option arguments in a header. */
+export declare function quoteDiffArgument(argument: string): string;
+export declare function expandTabs(line: string): string;
+export declare function sideBySide(changes: readonly Edit[], options: DisplayOptions, budget: Budget, append: (text: string) => void): Promise<void>;
+export declare function script(changes: readonly Edit[], format: "ed" | "rcs", budget: Budget, append: (text: string) => void): Promise<void>;
+export declare function ifdef(changes: readonly Edit[], symbol: string, budget: Budget, append: (text: string) => void): Promise<void>;

package/dist/safe-bash-command-diff/diff-output.js

@@ -0,0 +1,19 @@
+import {
+  colorText,
+  expandTabs,
+  ifdef,
+  quoteDiffArgument,
+  quoteDiffName,
+  script,
+  sideBySide
+} from "../safe-bash/command-chunks/chunk-6F4XCVON.js";
+import "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+export {
+  colorText,
+  expandTabs,
+  ifdef,
+  quoteDiffArgument,
+  quoteDiffName,
+  script,
+  sideBySide
+};

package/dist/safe-bash-command-diff/diff.d.ts

@@ -0,0 +1,2 @@
+import { type DiffPatchOptions } from "../safe-bash-diff-engine/shared.js";
+export declare function diffCommand(options?: DiffPatchOptions): import("../safe-bash-contracts/index.js").CommandDefinition;

package/dist/safe-bash-command-diff/diff.js

@@ -0,0 +1,10 @@
+import {
+  diffCommand
+} from "../safe-bash/command-chunks/chunk-Z7RVSD5K.js";
+import "../safe-bash/command-chunks/chunk-Y5INTD6S.js";
+import "../safe-bash/command-chunks/chunk-UG7SMZFF.js";
+import "../safe-bash/command-chunks/chunk-6F4XCVON.js";
+import "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+export {
+  diffCommand
+};

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

@@ -0,0 +1,8 @@
+import type { CommandDefinition, VirtualShellPlugin } from "../safe-bash-contracts/index.js";
+import type { DiffPatchOptions } from "../safe-bash-diff-engine/shared.js";
+export type { DiffPatchOptions as DiffCommandsOptions, DiffPatchOptions } from "../safe-bash-diff-engine/shared.js";
+export { diffCommand as createDiffCommand, diffCommand } from "./diff.js";
+export * from "./sync.js";
+export type DiffLimits = Omit<DiffPatchOptions, "replace">;
+export declare function createDiffCommands(options?: DiffPatchOptions): readonly CommandDefinition[];
+export declare function diffCommands(options?: DiffPatchOptions): VirtualShellPlugin;

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

@@ -0,0 +1,34 @@
+import {
+  diffCommand
+} from "../safe-bash/command-chunks/chunk-Z7RVSD5K.js";
+import "../safe-bash/command-chunks/chunk-Y5INTD6S.js";
+import {
+  evalSyncDiff
+} from "../safe-bash/command-chunks/chunk-AMO3THU4.js";
+import "../safe-bash/command-chunks/chunk-UG7SMZFF.js";
+import "../safe-bash/command-chunks/chunk-6F4XCVON.js";
+import {
+  init_buffer
+} from "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-diff/src/index.ts
+init_buffer();
+function createDiffCommands(options = {}) {
+  return [diffCommand(options)];
+}
+function diffCommands(options = {}) {
+  const commands = createDiffCommands(options);
+  return { name: "diff-commands", setup(host) {
+    if (!options.replace) for (const command of commands) {
+      if (host.commands.has(command.name)) throw new Error(`Command already registered: ${command.name}`);
+    }
+    for (const command of commands) host.commands.register(command, { replace: options.replace ?? false });
+  } };
+}
+export {
+  diffCommand as createDiffCommand,
+  createDiffCommands,
+  diffCommand,
+  diffCommands,
+  evalSyncDiff
+};

package/dist/safe-bash-command-diff/sync.d.ts

@@ -0,0 +1,2 @@
+export type { DiffPatchOptions } from "../safe-bash-diff-engine/shared.js";
+export declare function evalSyncDiff(stdinBytes: Uint8Array | undefined, args: readonly string[], readFile?: (path: string) => Uint8Array | undefined): string | undefined;

package/dist/safe-bash-command-diff/sync.js

@@ -0,0 +1,9 @@
+import {
+  evalSyncDiff
+} from "../safe-bash/command-chunks/chunk-AMO3THU4.js";
+import "../safe-bash/command-chunks/chunk-UG7SMZFF.js";
+import "../safe-bash/command-chunks/chunk-6F4XCVON.js";
+import "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+export {
+  evalSyncDiff
+};