@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -1,10 +1,10 @@
-import {
-  evalSyncDiff
-} from "../safe-bash/command-chunks/chunk-PFPJVC34.js";
 import {
   diffCommand
 } from "../safe-bash/command-chunks/chunk-K5EPXOZ3.js";
 import "../safe-bash/command-chunks/chunk-NP7GTGLW.js";
+import {
+  evalSyncDiff
+} from "../safe-bash/command-chunks/chunk-PFPJVC34.js";
 import "../safe-bash/command-chunks/chunk-QFFJN22S.js";
 import "../safe-bash/command-chunks/chunk-QKXGUVT4.js";
 import "../safe-bash/command-chunks/chunk-65DS4IOB.js";

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

@@ -0,0 +1,12 @@
+import { type CommandDefinition, type VirtualShellPlugin } from "../safe-bash-contracts/index.js";
+export interface DiffpdfLimits {
+    readonly maxInputBytes: number;
+    readonly maxPages: number;
+}
+export interface DiffpdfCommandsOptions {
+    readonly limits?: Partial<DiffpdfLimits>;
+    readonly replace?: boolean;
+}
+export declare function createDiffpdfCommand(options?: DiffpdfCommandsOptions): CommandDefinition;
+export declare function createDiffpdfCommands(options?: DiffpdfCommandsOptions): readonly CommandDefinition[];
+export declare function diffpdfCommands(options?: DiffpdfCommandsOptions): VirtualShellPlugin;

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

@@ -0,0 +1,107 @@
+import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
+
+// packages/safe-bash-command-diffpdf/src/index.ts
+import { commandRuntimeIdentity, getCommandArguments } from "../safe-bash-contracts/index.js";
+import { InputByteBudget, writeBytes } from "../safe-bash-contracts/io.js";
+import { resolvePath } from "../safe-bash-contracts/path.js";
+import { drainCooperativeSteps, yieldTurn } from "../safe-bash-contracts/yield.js";
+function createDiffpdfCommand(options = {}) {
+  const maxInputBytes = InputByteBudget.limit(options.limits?.maxInputBytes ?? 32 * 1024 * 1024);
+  const maxPages = InputByteBudget.limit(options.limits?.maxPages ?? 1e3);
+  return {
+    name: "diffpdf",
+    runtimeIdentity: commandRuntimeIdentity,
+    async execute(context) {
+      return new InputByteBudget(maxInputBytes, context.inputBudget).run(context, async (context2) => {
+        let mode = "text";
+        const files = [];
+        let positional = false;
+        for (const arg of getCommandArguments(context2).args) {
+          if (!positional && arg === "--") {
+            positional = true;
+            continue;
+          }
+          if (!positional && (arg === "--text" || arg === "--layout")) {
+            mode = arg === "--text" ? "text" : "layout";
+            continue;
+          }
+          if (!positional && arg === "--help") {
+            await writeBytes(context2.stdout, new TextEncoder().encode("Usage: diffpdf [--text|--layout] OLD.pdf NEW.pdf\nExit 0: equal, 1: different, 2: invalid invocation.\n"), context2.signal);
+            return { exitCode: 0 };
+          }
+          if (!positional && arg.startsWith("-")) {
+            await writeBytes(context2.stderr, new TextEncoder().encode(`diffpdf: unsupported option ${arg}
+`), context2.signal);
+            return { exitCode: 2 };
+          }
+          files.push(arg);
+        }
+        if (files.length !== 2) {
+          await writeBytes(context2.stderr, new TextEncoder().encode("diffpdf: expected two PDF files\n"), context2.signal);
+          return { exitCode: 2 };
+        }
+        const { PdfDocument, PdfError } = await import("../pdf-ast/index.js");
+        const documents = [];
+        for (const file of files) {
+          const bytes = await context2.fs.readFile(resolvePath(context2.cwd, file), { signal: context2.signal });
+          context2.signal.throwIfAborted();
+          let doc;
+          try {
+            doc = await drainCooperativeSteps(PdfDocument.loadSteps(bytes), context2.signal);
+          } catch (error) {
+            context2.signal.throwIfAborted();
+            if (!(error instanceof PdfError)) throw error;
+            await writeBytes(context2.stderr, new TextEncoder().encode(`diffpdf: ${file}: ${error.message}
+`), context2.signal);
+            return { exitCode: 2 };
+          }
+          if (doc.pageCount > maxPages) throw new RangeError("diffpdf: page limit exceeded");
+          documents.push(doc);
+        }
+        const [a, b] = documents;
+        let changed = false;
+        for (let index = 0; index < Math.max(a.pageCount, b.pageCount); index++) {
+          await yieldTurn(context2.signal);
+          const signature = (doc) => {
+            if (index >= doc.pageCount) return void 0;
+            const page = doc.getPage(index);
+            const lines = page.extractPage().blocks.flatMap((block) => block.lines);
+            return JSON.stringify(mode === "text" ? lines.map((line) => line.text) : {
+              size: page.getSize(),
+              rotation: page.getRotation(),
+              lines: lines.map((line) => ({
+                text: line.text,
+                bbox: line.bbox,
+                words: line.words.map((word) => ({ text: word.text, bbox: word.bbox, fontSize: word.fontSize, fontName: word.fontName }))
+              }))
+            });
+          };
+          if (signature(a) !== signature(b)) {
+            changed = true;
+            await writeBytes(context2.stdout, new TextEncoder().encode(`Page ${index + 1} differs (${mode})
+`), context2.signal);
+          }
+        }
+        return { exitCode: changed ? 1 : 0 };
+      });
+    }
+  };
+}
+function createDiffpdfCommands(options = {}) {
+  const command = createDiffpdfCommand(options);
+  return [command, { ...command, name: "pdfdiff" }];
+}
+function diffpdfCommands(options = {}) {
+  const commands = createDiffpdfCommands(options);
+  return { name: "diffpdf", 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 {
+  createDiffpdfCommand,
+  createDiffpdfCommands,
+  diffpdfCommands
+};

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

@@ -0,0 +1,36 @@
+import { type DocxInvocation, type DocxArgumentSource } from "../safe-bash-docx-engine/invocation.js";
+import { DocumentBudget, type DocumentLimits } from "../safe-bash-docx-engine/budget.js";
+export declare function parseDocxArguments(args: readonly Uint8Array[], budget?: DocumentBudget): DocxInvocation;
+export interface DocxCommandRequest {
+    readonly args: readonly Uint8Array[];
+    readonly stdin: AsyncIterable<Uint8Array>;
+    readonly stdout: {
+        write(bytes: Uint8Array): Promise<void>;
+    };
+    readonly stderr: {
+        write(bytes: Uint8Array): Promise<void>;
+    };
+    readonly signal: AbortSignal;
+}
+export type DocxCommandEngineResult<Result extends {
+    readonly exitCode: number;
+} = {
+    readonly exitCode: number;
+}> = {
+    readonly exitCode: number;
+} & Partial<Omit<Result, "exitCode">>;
+export declare function createDocxCommandEngine<Request extends DocxCommandRequest, Result extends {
+    readonly exitCode: number;
+} = {
+    readonly exitCode: number;
+}>(handler: {
+    execute(invocation: DocxInvocation, request: Request): Promise<Result>;
+    readSource?(source: DocxArgumentSource, request: Request, budget: DocumentBudget): Promise<Uint8Array>;
+}, hostLimits?: Partial<DocumentLimits>): {
+    execute(request: Request): Promise<DocxCommandEngineResult<Result>>;
+};
+export declare function commandDiagnostic(source: string, code: string, limit: number): {
+    message: string;
+    human: string;
+};
+export { SourceError, validateDocxInvocation, validateDocxBatch, docxInvocationBudgets, type DocxInvocation, type DocxArgumentSource, type DocxBatch, type DocxBatchOperation } from "../safe-bash-docx-engine/invocation.js";

package/dist/{safe-bash-docx-engine → safe-bash-command-docx}/discovery.d.ts

@@ -1,9 +1,9 @@
-import type { ArchiveLimits } from "./archive.js";
+import type { ArchiveLimits } from "../safe-bash-docx-engine/archive.js";
 import type { FileSystem } from "@poe-platform/safe-fs/core";
-import { documentValidationProfile } from "./validation.js";
-import { DocumentBudget } from "./budget.js";
+import { documentValidationProfile } from "../safe-bash-docx-engine/validation.js";
+import { DocumentBudget } from "../safe-bash-docx-engine/budget.js";
 import { type DocxInvocation } from "./command.js";
-import { type DocxJsonSchema } from "./operation-json-schema.js";
+import { type DocxJsonSchema } from "../safe-bash-docx-engine/operation-json-schema.js";
 export interface DocxHelpData {
     readonly name: "docx";
     readonly paths: readonly {

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

@@ -28,7 +28,7 @@ function createDocxCommand(options = {}) {
         if (bytes > maxArgumentBytes - argumentBytes) throw new FsError("EFBIG", { message: "document argument limit exceeded" });
         argumentBytes += bytes;
       }
-      engine ??= (await import("../safe-bash-docx-engine/index.js")).createDocxInspectionCommandEngine();
+      engine ??= (await import("../safe-bash/command-chunks/inspection-command-ULEU7ZVV.js")).createDocxInspectionCommandEngine();
       const result = await engine.execute({
         args: Object.freeze(arguments_.args.map((_, index) => arguments_.bytes(index))),
         cwd: context.cwd,

package/dist/{safe-bash-docx-engine → safe-bash-command-docx}/inspection-command.d.ts

@@ -1,11 +1,11 @@
-import { type DocumentModelContext } from "./model-context.js";
-import { type ArchiveExtractionData } from "./extract.js";
-import { type ObjectExtractionData } from "./objects.js";
+import { type DocumentModelContext } from "../safe-bash-docx-engine/model-context.js";
+import { type ArchiveExtractionData } from "../safe-bash-docx-engine/extract.js";
+import { type ObjectExtractionData } from "../safe-bash-docx-engine/objects.js";
 import { type FileSystem } from "@poe-platform/safe-fs/core";
-import { type ArchiveLimits } from "./archive.js";
-import { type DocumentLimits } from "./budget.js";
+import { type ArchiveLimits } from "../safe-bash-docx-engine/archive.js";
+import { type DocumentLimits } from "../safe-bash-docx-engine/budget.js";
 import { type DocxCommandRequest } from "./command.js";
-import { type ImageExtractionData } from "./images.js";
+import { type ImageExtractionData } from "../safe-bash-docx-engine/images.js";
 export interface DocxInspectionCommandRequest extends DocxCommandRequest {
     readonly cwd: string;
     readonly filesystem: Pick<FileSystem, "readFile" | "readStream"> & Partial<FileSystem>;

package/dist/safe-bash-command-docx/sdk.d.ts

@@ -0,0 +1,4 @@
+export * from "../safe-bash-docx-engine/index.js";
+export { parseDocxArguments, validateDocxInvocation, validateDocxBatch, createDocxCommandEngine, SourceError, type DocxInvocation, type DocxBatch, type DocxBatchOperation, type DocxArgumentSource, type DocxCommandRequest, type DocxCommandEngineResult } from "./command.js";
+export { getDocxDiscovery, inspectDocxCapabilities, type DocxDiscovery, type DocxHelpData, type DocxSchemaData, type DocxCapabilitiesData, type DocxVersionData } from "./discovery.js";
+export { createDocxInspectionCommandEngine, type DocxInspectionCommandRequest, type DocxInspectionCommandResult } from "./inspection-command.js";

package/dist/safe-bash-command-docx/sdk.js

@@ -0,0 +1,24 @@
+import {
+  SourceError,
+  createDocxCommandEngine,
+  createDocxInspectionCommandEngine,
+  getDocxDiscovery,
+  inspectDocxCapabilities,
+  parseDocxArguments,
+  validateDocxBatch,
+  validateDocxInvocation
+} from "../safe-bash/command-chunks/chunk-XFMJ4RMS.js";
+import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
+
+// packages/safe-bash-command-docx/src/sdk.ts
+export * from "../safe-bash-docx-engine/index.js";
+export {
+  SourceError,
+  createDocxCommandEngine,
+  createDocxInspectionCommandEngine,
+  getDocxDiscovery,
+  inspectDocxCapabilities,
+  parseDocxArguments,
+  validateDocxBatch,
+  validateDocxInvocation
+};

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

@@ -0,0 +1,14 @@
+import { type CommandDefinition, type VirtualShellPlugin } from "../safe-bash-contracts/index.js";
+export interface DotLimits {
+    readonly maxInputBytes: number;
+    readonly maxNodes: number;
+    readonly maxPixels: number;
+    readonly maxLayoutCost: number;
+}
+export interface DotCommandsOptions {
+    readonly limits?: Partial<DotLimits>;
+    readonly replace?: boolean;
+}
+export declare function createDotCommand(options?: DotCommandsOptions): CommandDefinition;
+export declare function createDotCommands(options?: DotCommandsOptions): readonly CommandDefinition[];
+export declare function dotCommands(options?: DotCommandsOptions): VirtualShellPlugin;