@poe-platform/safe-bash 0.1.540 → 0.1.541

package/dist/safe-bash/core.browser.js

@@ -2,12 +2,18 @@ import {
   createGetoptCommand,
   createGetoptCommands,
   getoptCommands
-} from "./chunks/chunk-LRVRQIG5.js";
+} from "./chunks/chunk-EZLQA6ON.js";
+import {
+  createHdCommand,
+  createHexdumpCommand,
+  createHexdumpCommands,
+  hexdumpCommands
+} from "./chunks/chunk-R3QJL5HH.js";
 import {
   createXmlCommands,
   defaultXmlQueryLimits,
   xmlCommands
-} from "./chunks/chunk-ZQEL7DYC.js";
+} from "./chunks/chunk-HFEU5SBQ.js";
 import {
   Interpreter,
   createYqCommand,
@@ -18,7 +24,7 @@ import {
   rawValues,
   stringify,
   yqCommands
-} from "./chunks/chunk-QKQNBJOU.js";
+} from "./chunks/chunk-YEJBZLE5.js";
 import {
   Budget,
   JqError,
@@ -31,7 +37,7 @@ import {
   resolveJqLimits,
   truth,
   wellFormed
-} from "./chunks/chunk-PPPN3OME.js";
+} from "./chunks/chunk-6PSMEBVP.js";
 import {
   CurlError,
   cloudflareWorkerNetworkLimits,
@@ -44,7 +50,7 @@ import {
   curlCommands,
   defaultNetworkLimits,
   networkCommands
-} from "./chunks/chunk-IIWXPQB3.js";
+} from "./chunks/chunk-TPD45VUZ.js";
 import {
   RecordBuffer,
   UsageError,
@@ -76,7 +82,7 @@ import {
   textOutputRequirements,
   value,
   writeDiagnostic
-} from "./chunks/chunk-J4CKSMJV.js";
+} from "./chunks/chunk-T5BV7HPD.js";
 import {
   AvailableRecords,
   EreLedger,
@@ -96,22 +102,22 @@ import {
   exprMatchCeilings,
   matchEre,
   withRegexSession
-} from "./chunks/chunk-Z75O7XWR.js";
+} from "./chunks/chunk-WODV2DVM.js";
 import {
   bindFileOutputBudget,
   openFileOutput,
   writeFileOutput
-} from "./chunks/chunk-32GGX4AS.js";
+} from "./chunks/chunk-AZNI263O.js";
 import {
   createPrCommand,
   createPrCommands,
   prCommands
-} from "./chunks/chunk-UGMO7OO5.js";
+} from "./chunks/chunk-VNDFKT6F.js";
 import {
   createTsortCommand,
   createTsortCommands,
   tsortCommands
-} from "./chunks/chunk-LZUOZVGJ.js";
+} from "./chunks/chunk-WF4P7XKI.js";
 import {
   basename,
   dirname,
@@ -126,10 +132,10 @@ import {
   createFactorCommand,
   createFactorCommands,
   factorCommands
-} from "./chunks/chunk-DJHZJAB7.js";
+} from "./chunks/chunk-66VSWIUC.js";
 import {
   createOutputOperation
-} from "./chunks/chunk-EYJTLUBJ.js";
+} from "./chunks/chunk-PZMJ4EC3.js";
 import {
   CommandArgumentIdentityError,
   CommandRegistry,
@@ -142,6 +148,7 @@ import {
   createBytePipe,
   createCommandArguments,
   getCommandArguments,
+  inheritYieldCheckpoint,
   isErrnoCode,
   isFsError,
   monotonicNow,
@@ -162,7 +169,7 @@ import {
   writeBytes,
   writeText,
   yieldTurn
-} from "./chunks/chunk-GZKLXMBM.js";
+} from "./chunks/chunk-5VBLSPNM.js";
 import {
   import_buffer,
   init_platform
@@ -17254,6 +17261,7 @@ init_platform();
 
 // packages/safe-bash/src/commands/bytes/compression/files.ts
 init_platform();
+import { retainFileSystemCleanup } from "@poe-platform/safe-fs/core";
 
 // packages/safe-bash/src/commands/bytes/compression/options.ts
 init_platform();
@@ -20871,6 +20879,7 @@ async function* split2(source2, signal, fail4) {
 async function transform(source2, consume, options2, parentSignal, maxOutput = Infinity) {
   const controller = new AbortController();
   const signal = AbortSignal.any([parentSignal, controller.signal]);
+  inheritYieldCheckpoint(parentSignal, signal);
   let failure;
   let hasFailure = false;
   const fail4 = (error) => {
@@ -20926,15 +20935,153 @@ async function transform(source2, consume, options2, parentSignal, maxOutput = I
   return warned2;
 }
 
+// packages/safe-bash/src/commands/bytes/compression/file-operation.ts
+init_platform();
+var FileOperation = class {
+  signal;
+  fs;
+  controller = new AbortController();
+  pending = /* @__PURE__ */ new Set();
+  sources = [];
+  closing;
+  caller;
+  constructor(context2, cleanup) {
+    this.caller = context2.signal;
+    this.signal = this.controller.signal;
+    this.caller.throwIfAborted();
+    inheritYieldCheckpoint(this.caller, this.signal);
+    const filesystem = context2.fs;
+    this.caller.throwIfAborted();
+    this.fs = new Proxy(filesystem, {
+      get: (target, key) => {
+        this.check();
+        const value2 = Reflect.get(target, key, target);
+        this.check();
+        return typeof value2 === "function" ? (...args) => {
+          this.check();
+          const result2 = Reflect.apply(value2, target, args);
+          return key === "readStream" ? this.ownSource(result2) : result2;
+        } : value2;
+      }
+    });
+    let outcomeClaimed = false;
+    let registeredClosing;
+    const abort = () => {
+      void retire().catch(() => {
+      });
+    };
+    const retire = () => {
+      if (!this.closing) {
+        this.closing = Promise.resolve().then(async () => {
+          try {
+            const sources2 = Promise.allSettled(this.sources.map((close) => close()));
+            await Promise.allSettled([...this.pending]);
+            const outcomes = await sources2;
+            await cleanup?.();
+            const failures = outcomes.filter((outcome) => outcome.status === "rejected").map((outcome) => outcome.reason);
+            if (failures.length === 1) throw failures[0];
+            if (failures.length) throw new AggregateError(failures, "Compression source cleanup failed");
+          } finally {
+            this.caller.removeEventListener("abort", abort);
+          }
+        });
+        void this.closing.catch(() => {
+        });
+        this.controller.abort(this.caller.aborted ? this.caller.reason : new Error("Compression file operation is closed"));
+      }
+      return this.closing;
+    };
+    this.close = () => {
+      outcomeClaimed = true;
+      return retire();
+    };
+    const register = context2.registerCleanup;
+    this.check();
+    if (register) Reflect.apply(register, context2, [() => {
+      registeredClosing ??= retire().catch((error) => {
+        if (!outcomeClaimed) throw error;
+      });
+      void registeredClosing.catch(() => {
+      });
+      return registeredClosing;
+    }]);
+    this.check();
+    this.caller.addEventListener("abort", abort, { once: true });
+    if (this.caller.aborted) abort();
+  }
+  close;
+  check() {
+    this.caller.throwIfAborted();
+    this.signal.throwIfAborted();
+  }
+  async run(start) {
+    this.check();
+    const pending = Promise.resolve().then(() => {
+      this.check();
+      return start();
+    });
+    this.pending.add(pending);
+    try {
+      return await pending;
+    } finally {
+      this.pending.delete(pending);
+    }
+  }
+  ownSource(source2) {
+    let iterator = void 0;
+    let closing;
+    const close = () => {
+      closing ??= Promise.resolve().then(async () => {
+        const method = iterator?.return;
+        return method ? await Reflect.apply(method, iterator, []) : { done: true, value: void 0 };
+      });
+      void closing.catch(() => {
+      });
+      return closing;
+    };
+    this.sources.push(close);
+    const factory = source2[Symbol.asyncIterator];
+    iterator = Reflect.apply(factory, source2, []);
+    this.check();
+    let claimed = false;
+    return {
+      [Symbol.asyncIterator]: () => {
+        this.check();
+        if (claimed) throw new Error("Compression input was already acquired");
+        claimed = true;
+        return {
+          next: async () => {
+            this.check();
+            if (closing) throw new Error("Compression input is closed");
+            const method = iterator.next;
+            this.check();
+            const result2 = await Reflect.apply(method, iterator, []);
+            this.check();
+            const done = result2.done;
+            this.check();
+            const value2 = result2.value;
+            this.check();
+            return done ? { done: true, value: value2 } : { done: false, value: value2 };
+          },
+          return: close
+        };
+      }
+    };
+  }
+};
+
 // packages/safe-bash/src/commands/bytes/compression/files.ts
+function identified(stat) {
+  return stat.identityScope !== void 0 && Number.isSafeInteger(stat.ino) && Number.isSafeInteger(stat.dev);
+}
 function sameIdentity(first, second) {
-  return first.ino !== void 0 && second.ino !== void 0 && first.ino === second.ino && first.dev === second.dev;
+  return identified(first) && identified(second) && first.identityScope === second.identityScope && first.ino === second.ino && first.dev === second.dev;
 }
 function sameSnapshot(first, second) {
-  return first.type === second.type && first.size === second.size && first.mode === second.mode && first.mtimeMs === second.mtimeMs && first.ctimeMs === second.ctimeMs && first.ino === second.ino && first.dev === second.dev && first.nlink === second.nlink && first.birthtimeMs === second.birthtimeMs && first.uid === second.uid && first.gid === second.gid;
+  return first.type === second.type && first.size === second.size && first.mode === second.mode && first.mtimeMs === second.mtimeMs && first.ctimeMs === second.ctimeMs && first.ino === second.ino && first.dev === second.dev && first.nlink === second.nlink && first.birthtimeMs === second.birthtimeMs && first.uid === second.uid && first.gid === second.gid && first.identityScope === second.identityScope;
 }
 function sameEntry(first, second) {
-  return first.type === second.type && first.ino === second.ino && first.dev === second.dev && first.birthtimeMs === second.birthtimeMs;
+  return sameIdentity(first, second) && first.type === second.type && first.birthtimeMs === second.birthtimeMs;
 }
 async function existing(context2, path) {
   try {
@@ -20970,6 +21117,15 @@ function outputPath(source2, options2) {
   return source2 + ".gz";
 }
 async function planOperands(context2, options2) {
+  const operation2 = new FileOperation(context2);
+  try {
+    return await operation2.run(() => collectOperands({ ...context2, fs: operation2.fs, signal: operation2.signal }, options2));
+  } finally {
+    await operation2.close();
+    context2.signal.throwIfAborted();
+  }
+}
+async function collectOperands(context2, options2) {
   const plans = [];
   for (const name2 of options2.operands) {
     context2.signal.throwIfAborted();
@@ -21003,6 +21159,13 @@ async function planOperands(context2, options2) {
       throw new FsError("ENOTSUP", { message: "file output requires VFS streaming writes (use -c for stdout)" });
     }
     const destinationStat = await existing(context2, destination2);
+    if (!identified(sourceStat) || destinationStat && !identified(destinationStat)) {
+      throw new FsError("ENOTSUP", { path: source2, message: "file output requires stable scoped entry identities" });
+    }
+    if (!context2.fs.rmdir || capabilities.exclusiveCreate !== true || (destinationStat ? capabilities.atomicRename : capabilities.atomicRenameNoReplace) !== true) {
+      throw new FsError("ENOTSUP", { path: destination2, message: "file output requires exclusive staging, safe rmdir and atomic publication (use -c for stdout)" });
+    }
+    context2.signal.throwIfAborted();
     if (destinationStat) {
       if (destinationStat.type !== "file" || sameIdentity(sourceStat, destinationStat) || realSource === await context2.fs.realpath(destination2, { signal: context2.signal })) {
         throw new FsError("EINVAL", { path: destination2, message: "destination is not a distinct regular file" });
@@ -21033,23 +21196,10 @@ async function unchangedSource(context2, plan) {
     throw new FsError("EBUSY", { path: plan.source, message: "input identity or metadata changed; input retained" });
   }
 }
-async function temporaryDirectory(context2, destination2) {
-  for (let attempt = 0; attempt < 16; attempt++) {
-    const path = joinPath(dirname(destination2), `.virtual-bash-gzip-${globalThis.crypto.randomUUID()}`);
-    try {
-      await context2.fs.mkdir(path, { mode: 448, signal: context2.signal });
-      return path;
-    } catch (error) {
-      if (codeOf(error) !== "EEXIST") throw error;
-    }
-  }
-  throw new FsError("EEXIST", { message: "unable to allocate a private gzip staging directory" });
-}
 async function writeFileOperand(context2, plan, options2) {
   const destination2 = plan.destination;
-  await unchangedSource(context2, plan);
-  const directory2 = await temporaryDirectory(context2, destination2);
-  const staged = joinPath(directory2, "data");
+  let directory2;
+  let staged;
   let directoryStat;
   let stageStat;
   let stageOwned = false;
@@ -21057,69 +21207,121 @@ async function writeFileOperand(context2, plan, options2) {
   let failure;
   let failed = false;
   let warned2 = false;
+  let cleanupFailed = false;
+  let retainedCleanup;
+  const operation2 = new FileOperation(context2, async () => {
+    await retainedCleanup?.();
+  });
+  const active = { ...context2, fs: operation2.fs, signal: operation2.signal };
+  const { fs, signal } = active;
+  const snapshot = (stat) => {
+    const result2 = {};
+    for (const key of ["type", "size", "mode", "mtimeMs", "atimeMs", "ctimeMs", "birthtimeMs", "identityScope", "ino", "dev", "nlink", "uid", "gid"]) {
+      result2[key] = stat[key];
+      operation2.check();
+    }
+    return Object.freeze(result2);
+  };
   try {
-    directoryStat = await context2.fs.lstat(directory2, { signal: context2.signal });
-    if (directoryStat.type !== "directory") throw new FsError("EBUSY", { path: directory2 });
-    await context2.fs.writeFile(staged, new Uint8Array(), { flag: "wx", mode: 384, signal: context2.signal });
-    stageOwned = true;
-    stageStat = await context2.fs.lstat(staged, { signal: context2.signal });
-    if (stageStat.type !== "file" || stageStat.size !== 0) throw new FsError("EBUSY", { path: staged });
-    warned2 = await transform((signal) => context2.fs.readStream(plan.source, { signal, chunkSize: chunkBytes }), async (output2, signal) => {
-      await context2.fs.writeStream(staged, output2, { flag: "w", mode: 384, signal });
-    }, { ...options2, force: false }, context2.signal, stagingLimit);
-    await unchangedSource(context2, plan);
-    const target = await existing(context2, destination2);
+    retainedCleanup = retainFileSystemCleanup(context2.fs, async (cleanup) => {
+      if (directory2 === void 0) return;
+      const cleanupSignal = AbortSignal.timeout(5e3);
+      const currentDirectory = await cleanup.lstat(directory2, { signal: cleanupSignal });
+      if (!directoryStat || !sameEntry(directoryStat, currentDirectory)) {
+        throw new FsError("EBUSY", { path: directory2, message: "staging directory identity is unknown or changed; refusing cleanup" });
+      }
+      if (stageOwned && !moved && staged !== void 0) {
+        let currentStage;
+        try {
+          currentStage = await cleanup.lstat(staged, { signal: cleanupSignal });
+        } catch (error) {
+          if (codeOf(error) !== "ENOENT") throw error;
+        }
+        if (currentStage) {
+          if (!stageStat || !sameEntry(stageStat, currentStage)) throw new FsError("EBUSY", { path: staged, message: "staging file identity changed; refusing cleanup" });
+          await cleanup.rm(staged, { signal: cleanupSignal });
+        }
+      }
+      if (!cleanup.rmdir) throw new FsError("ENOTSUP", { path: directory2, message: "safe directory removal unavailable" });
+      try {
+        await cleanup.rmdir(directory2, { signal: cleanupSignal });
+      } catch (error) {
+        if (codeOf(error) === "ENOTEMPTY") throw new FsError("ENOTEMPTY", { path: directory2, message: "unexpected staging entries; refusing cleanup" });
+        throw error;
+      }
+    }, { maxOperations: 8 });
+    operation2.check();
+    await operation2.run(() => unchangedSource(active, plan));
+    for (let attempt = 0; directory2 === void 0 && attempt < 16; attempt++) {
+      const path = joinPath(dirname(destination2), `.virtual-bash-gzip-${globalThis.crypto.randomUUID()}`);
+      const capabilities = await operation2.run(async () => await fs.capabilitiesFor?.(path, { signal, create: true, allowDirectory: true }) ?? fs.capabilities);
+      operation2.check();
+      const snapshotRmdir = capabilities.snapshotRmdir;
+      operation2.check();
+      if (snapshotRmdir === true) throw new FsError("ENOTSUP", { path, message: "strong staging directory cleanup unavailable; snapshot-only rmdir is unsupported" });
+      try {
+        await operation2.run(async () => {
+          await fs.mkdir(path, { mode: 448, signal });
+          directory2 = path;
+        });
+      } catch (error) {
+        operation2.check();
+        if (codeOf(error) !== "EEXIST") throw error;
+      }
+    }
+    if (directory2 === void 0) throw new FsError("EEXIST", { message: "unable to allocate a private gzip staging directory" });
+    staged = joinPath(directory2, "data");
+    directoryStat = snapshot(await operation2.run(() => fs.lstat(directory2, { signal })));
+    if (directoryStat.type !== "directory" || !identified(directoryStat)) throw new FsError("EBUSY", { path: directory2 });
+    await operation2.run(async () => {
+      await fs.writeFile(staged, new Uint8Array(), { flag: "wx", mode: 384, signal });
+      stageOwned = true;
+    });
+    stageStat = snapshot(await operation2.run(() => fs.lstat(staged, { signal })));
+    if (stageStat.type !== "file" || stageStat.size !== 0 || !identified(stageStat)) throw new FsError("EBUSY", { path: staged });
+    warned2 = await operation2.run(() => transform((signal2) => fs.readStream(plan.source, { signal: signal2, chunkSize: chunkBytes }), async (output2, signal2) => {
+      await fs.writeStream(staged, output2, { flag: "w", mode: 384, signal: signal2 });
+    }, { ...options2, force: false }, signal, stagingLimit));
+    await operation2.run(() => unchangedSource(active, plan));
+    const target = await operation2.run(() => existing(active, destination2));
     if (plan.destinationStat ? !target || !sameSnapshot(plan.destinationStat, target) : target !== void 0) {
       throw new FsError("EBUSY", { path: destination2, message: "destination changed during compression" });
     }
-    if (!sameEntry(stageStat, await context2.fs.lstat(staged, { signal: context2.signal }))) {
+    if (!sameEntry(stageStat, snapshot(await operation2.run(() => fs.lstat(staged, { signal }))))) {
       throw new FsError("EBUSY", { path: staged, message: "staging identity changed" });
     }
-    if (plan.destinationStat) {
-      await context2.fs.rename(staged, destination2, { signal: context2.signal });
+    await operation2.run(async () => {
+      await fs.rename(staged, destination2, { signal, noReplace: !plan.destinationStat });
       moved = true;
-    } else await context2.fs.copyFile(staged, destination2, { exclusive: true, signal: context2.signal });
-    context2.signal.throwIfAborted();
+    });
+    operation2.check();
+    try {
+      await retainedCleanup();
+    } catch (error) {
+      cleanupFailed = true;
+      throw error;
+    }
+    operation2.check();
+    if (!options2.keep) {
+      await operation2.run(() => unchangedSource(active, plan));
+      await operation2.run(() => fs.rm(plan.source, { signal }));
+    }
   } catch (error) {
     failed = true;
     failure = error;
   }
   try {
-    const signal = AbortSignal.timeout(5e3);
-    const currentDirectory = await context2.fs.lstat(directory2, { signal });
-    if (directoryStat && !sameEntry(directoryStat, currentDirectory)) {
-      throw new FsError("EBUSY", { path: directory2, message: "staging directory identity changed; refusing cleanup" });
-    }
-    if (stageOwned && !moved) {
-      let currentStage;
-      try {
-        currentStage = await context2.fs.lstat(staged, { signal });
-      } catch (error) {
-        if (codeOf(error) !== "ENOENT") throw error;
-      }
-      if (currentStage) {
-        if (!stageStat || !sameEntry(stageStat, currentStage)) {
-          throw new FsError("EBUSY", { path: staged, message: "staging file identity changed; refusing cleanup" });
-        }
-        await context2.fs.rm(staged, { signal });
-      }
-    }
-    if ((await context2.fs.readdir(directory2, { signal })).length) {
-      throw new FsError("ENOTEMPTY", { path: directory2, message: "unexpected staging entries; refusing recursive cleanup" });
-    }
-    await context2.fs.rm(directory2, { recursive: true, signal });
+    await operation2.close();
   } catch (error) {
+    if (cleanupFailed && error === failure) throw error;
     if (failed) {
       const aggregate = new AggregateError([failure, error], "compression failed and staging cleanup failed; input retained");
       throw new PublicDiagnostic(aggregate.message, { cause: aggregate });
     }
     throw error;
   }
+  context2.signal.throwIfAborted();
   if (failed) throw failure;
-  if (!options2.keep) {
-    await unchangedSource(context2, plan);
-    await context2.fs.rm(plan.source, { signal: context2.signal });
-  }
   return warned2;
 }
 
@@ -26822,7 +27024,7 @@ async function writeZipArchive(archive, limits, signal) {
 
 // packages/safe-bash/src/commands/archive/zip/safety.ts
 init_platform();
-import { retainFileSystemCleanup } from "@poe-platform/safe-fs/core";
+import { retainFileSystemCleanup as retainFileSystemCleanup2 } from "@poe-platform/safe-fs/core";
 var ZipScope = class {
   constructor(original, limits) {
     this.original = original;
@@ -26930,7 +27132,7 @@ async function publishZip(scope, prepared) {
     const owner = directory2 && await scope.stat(directory2.path);
     if (parent !== prepared.parent || !owner || owner.type !== "directory" || !sameIdentity2(owner, directory2.stat)) fail("ZIP temporary ownership changed before mutation");
   };
-  const close = retainFileSystemCleanup(fs, async (cleanup) => {
+  const close = retainFileSystemCleanup2(fs, async (cleanup) => {
     if (!directory2 || !hasIdentity(directory2.stat)) return;
     const parent = await cleanup.realpath(prepared.parentName);
     const owner = await cleanup.lstat(directory2.path);
@@ -27435,7 +27637,7 @@ var Answers = class {
 
 // packages/safe-bash/src/commands/archive/unzip/safety.ts
 init_platform();
-import { retainFileSystemCleanup as retainFileSystemCleanup2 } from "@poe-platform/safe-fs/core";
+import { retainFileSystemCleanup as retainFileSystemCleanup3 } from "@poe-platform/safe-fs/core";
 var Extraction = class {
   constructor(context2, limits) {
     this.context = context2;
@@ -27622,7 +27824,7 @@ var Extraction = class {
     let identity2;
     let created = false;
     let failure;
-    const cleanup = retainFileSystemCleanup2(fs, async (view) => {
+    const cleanup = retainFileSystemCleanup3(fs, async (view) => {
       if (!created || !identity2) return;
       try {
         let parent = "/";
@@ -36599,6 +36801,7 @@ function composeAgentCommands(options2, executors) {
   const tsortLimits = options2.tsort?.limits;
   const factorLimits = options2.factor?.limits;
   const getoptLimits = options2.getopt?.limits;
+  const hexdumpLimits = options2.hexdump?.limits;
   const whichLimits = options2.which?.limits;
   const timeoutOptions = options2.timeout;
   const applyPatchLimits = options2.applyPatch?.limits;
@@ -36636,7 +36839,8 @@ function composeAgentCommands(options2, executors) {
     ...createPrCommands({ ...prLimits === void 0 ? {} : { limits: prLimits }, ...prClock === void 0 ? {} : { clock: prClock } }),
     ...createTsortCommands(tsortLimits === void 0 ? {} : { limits: tsortLimits }),
     ...createFactorCommands(factorLimits === void 0 ? {} : { limits: factorLimits }),
-    ...createGetoptCommands(getoptLimits === void 0 ? {} : { limits: getoptLimits })
+    ...createGetoptCommands(getoptLimits === void 0 ? {} : { limits: getoptLimits }),
+    ...createHexdumpCommands(hexdumpLimits === void 0 ? {} : { limits: hexdumpLimits })
   );
   return new CommandRegistry(commands).list();
 }
@@ -53020,6 +53224,9 @@ export {
   createGetoptCommand,
   createGetoptCommands,
   createGrepAliasCommands,
+  createHdCommand,
+  createHexdumpCommand,
+  createHexdumpCommands,
   createHtmlToMarkdownCommand,
   createHtmlToMarkdownCommands,
   createMemoryFileSystem2 as createMemoryFileSystem,
@@ -53077,6 +53284,7 @@ export {
   getCommandArguments,
   getoptCommands,
   grepAliasCommands,
+  hexdumpCommands,
   htmlToMarkdownCommands,
   isAbsolutePath3 as isAbsolutePath,
   isErrnoCode,