@thi.ng/block-fs 0.5.10 → 0.6.1

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2025-07-10T14:20:23Z
+- **Last updated**: 2025-07-12T12:28:22Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.
@@ -11,6 +11,23 @@ See [Conventional Commits](https://conventionalcommits.org/) for commit guidelin
 **Note:** Unlisted _patch_ versions only involve non-code or otherwise excluded changes
 and/or version bumps of transitive dependencies.
 
+### [0.6.1](https://github.com/thi-ng/umbrella/tree/@thi.ng/block-fs@0.6.1) (2025-07-12)
+
+#### 🩹 Bug fixes
+
+- fix tree output in CLI list cmd, update deps ([8d33970](https://github.com/thi-ng/umbrella/commit/8d33970))
+  - update entry sorting for tree output to avoid order edge cases w/ prev approach
+
+## [0.6.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/block-fs@0.6.0) (2025-07-11)
+
+#### 🚀 Features
+
+- update Directory.tree(), add optional comparator ([a3c7f4c](https://github.com/thi-ng/umbrella/commit/a3c7f4c))
+
+#### ♻️ Refactoring
+
+- split out CLI cmds to own files, fix tree display ([8665244](https://github.com/thi-ng/umbrella/commit/8665244))
+
 ### [0.5.3](https://github.com/thi-ng/umbrella/tree/@thi.ng/block-fs@0.5.3) (2025-06-27)
 
 #### ♻️ Refactoring

package/README.md

@@ -294,7 +294,7 @@ For Node.js REPL:
 const bf = await import("@thi.ng/block-fs");
 ```
 
-Package sizes (brotli'd, pre-treeshake): ESM: 4.29 KB
+Package sizes (brotli'd, pre-treeshake): ESM: 4.33 KB
 
 ## Dependencies
 
@@ -303,6 +303,7 @@ Package sizes (brotli'd, pre-treeshake): ESM: 4.29 KB
 - [@thi.ng/binary](https://github.com/thi-ng/umbrella/tree/develop/packages/binary)
 - [@thi.ng/bitfield](https://github.com/thi-ng/umbrella/tree/develop/packages/bitfield)
 - [@thi.ng/checks](https://github.com/thi-ng/umbrella/tree/develop/packages/checks)
+- [@thi.ng/compare](https://github.com/thi-ng/umbrella/tree/develop/packages/compare)
 - [@thi.ng/errors](https://github.com/thi-ng/umbrella/tree/develop/packages/errors)
 - [@thi.ng/file-io](https://github.com/thi-ng/umbrella/tree/develop/packages/file-io)
 - [@thi.ng/logger](https://github.com/thi-ng/umbrella/tree/develop/packages/logger)

package/api.d.ts

@@ -1,4 +1,4 @@
-import type { Maybe } from "@thi.ng/api";
+import type { Comparator, Maybe } from "@thi.ng/api";
 import type { Pow2 } from "@thi.ng/binary";
 import type { ILogger } from "@thi.ng/logger";
 import type { BlockFS } from "./fs.js";
@@ -66,7 +66,7 @@ export interface IEntry extends Required<EntrySpec> {
 export interface IDirectory extends AsyncIterable<IEntry> {
     readonly fs: BlockFS;
     readonly entry: IEntry;
-    tree(): AsyncIterableIterator<IEntry>;
+    tree(cmp?: Comparator<IEntry>): AsyncIterableIterator<IEntry>;
     traverse(): Promise<{
         blocks: number[];
         entries: IEntry[];

package/cli/api.d.ts

@@ -0,0 +1,21 @@
+import { type CommandCtx } from "@thi.ng/args";
+export interface CLIOpts {
+    verbose: boolean;
+    quiet: boolean;
+}
+export declare const ARG_BLOCKSIZE: {
+    blockSize: {
+        alias: string;
+        desc: string;
+        hint: string;
+        default: number;
+        coerce: (x: string) => import("@thi.ng/binary").Pow2;
+    } & {
+        coerce: import("@thi.ng/api").Fn<string, number>;
+        hint: string;
+        group: string;
+    };
+};
+export interface AppCtx<T extends CLIOpts> extends CommandCtx<T, CLIOpts> {
+}
+//# sourceMappingURL=api.d.ts.map

package/cli/api.js

@@ -0,0 +1,19 @@
+import { int } from "@thi.ng/args";
+import { isPow2 } from "@thi.ng/binary";
+import { illegalArgs } from "@thi.ng/errors";
+const ARG_BLOCKSIZE = {
+  blockSize: int({
+    alias: "bs",
+    desc: "Block size",
+    hint: "BYTES",
+    default: 1024,
+    coerce: (x) => {
+      const size = +x;
+      if (!isPow2(size)) illegalArgs("block size must be a power of 2");
+      return size;
+    }
+  })
+};
+export {
+  ARG_BLOCKSIZE
+};

package/cli/convert.d.ts

@@ -0,0 +1,11 @@
+import { type Command } from "@thi.ng/args";
+import { type AppCtx, type CLIOpts } from "./api.js";
+export interface ConvertOpts extends CLIOpts {
+    numBlocks?: number;
+    blockSize: number;
+    exclude?: string[];
+    include?: string[];
+    out: string;
+}
+export declare const CONVERT: Command<ConvertOpts, CLIOpts, AppCtx<ConvertOpts>>;
+//# sourceMappingURL=convert.d.ts.map

package/cli/convert.js

@@ -0,0 +1,124 @@
+import { int, string, strings } from "@thi.ng/args";
+import { align } from "@thi.ng/binary";
+import { files, readBinary, writeFile } from "@thi.ng/file-io";
+import { statSync } from "node:fs";
+import { relative, resolve } from "node:path";
+import { Entry } from "../entry.js";
+import { BlockFS } from "../fs.js";
+import { MemoryBlockStorage } from "../storage/memory.js";
+import { ARG_BLOCKSIZE } from "./api.js";
+const CONVERT = {
+  opts: {
+    ...ARG_BLOCKSIZE,
+    numBlocks: int({
+      alias: "n",
+      desc: "Number of blocks (multiple of 8)",
+      optional: true
+    }),
+    out: string({
+      alias: "o",
+      desc: "Output file path",
+      optional: false
+    }),
+    exclude: strings({
+      alias: "e",
+      desc: "File exclusion regexp",
+      hint: "EXT"
+    }),
+    include: strings({
+      alias: "i",
+      desc: "File inclusion regexp",
+      hint: "EXT"
+    })
+  },
+  desc: "Convert file tree into single BlockFS blob",
+  fn: async (ctx) => {
+    const collected = collectFiles(ctx);
+    const numBlocks = align(
+      ctx.opts.numBlocks ?? computeBlockCount(collected, ctx.opts.blockSize, ctx.logger),
+      8
+    );
+    ctx.logger.info("number of files:", collected.files.length);
+    ctx.logger.info("number of directories:", collected.dirs.length);
+    ctx.logger.info("total file size:", collected.size);
+    ctx.logger.info("number of blocks:", numBlocks);
+    const storage = new MemoryBlockStorage({
+      numBlocks,
+      blockSize: ctx.opts.blockSize,
+      logger: ctx.logger
+    });
+    const bfs = new BlockFS(storage, { logger: ctx.logger });
+    await bfs.init();
+    ctx.logger.info("root dir block:", bfs.rootDirBlockID);
+    ctx.logger.info("first data block:", bfs.dataStartBlockID);
+    ctx.logger.info("block data size:", bfs.blockDataSize);
+    for (let f of collected.files) {
+      const data = readBinary(f.src, ctx.logger);
+      ctx.logger.info("writing file:", f.dest, "size:", data.length);
+      await bfs.writeFile(f.dest, data);
+      const entry = await bfs.entryForPath(f.dest);
+      entry.ctime = f.ctime;
+      entry.mtime = f.mtime;
+      await entry.save();
+    }
+    writeFile(ctx.opts.out, storage.buffer, void 0, ctx.logger);
+  }
+};
+const pathsForFile = (f) => {
+  const parts = f.split("/");
+  const dirs = [];
+  for (let i = 1; i < parts.length; i++)
+    dirs.push(parts.slice(0, i).join("/"));
+  return dirs;
+};
+const collectFiles = ({
+  opts: { include, exclude },
+  inputs
+}) => {
+  const root = resolve(inputs[0]);
+  const filtered = [];
+  const dirs = /* @__PURE__ */ new Set();
+  const $include = include?.map((x) => new RegExp(x));
+  const $exclude = exclude?.map((x) => new RegExp(x));
+  let total = 0;
+  for (let f of files(root)) {
+    const stats = statSync(f);
+    if ($exclude && $exclude.some((x) => x.test(f))) continue;
+    if ($include && !$include.some((x) => x.test(f))) continue;
+    const dest = relative(root, f);
+    filtered.push({
+      src: f,
+      dest,
+      size: stats.size,
+      ctime: stats.ctimeMs,
+      mtime: stats.mtimeMs
+    });
+    for (let d of pathsForFile(dest)) dirs.add(d);
+    total += stats.size;
+  }
+  return { files: filtered, dirs: [...dirs], size: total };
+};
+const computeBlockCount = (collected, blockSize, logger, numBlocks) => {
+  let blocks = collected.dirs.length;
+  const blockIDBytes = requiredBytes(
+    numBlocks ?? collected.size / blockSize + blocks
+  );
+  const blockDataSizeBytes = requiredBytes(blockSize);
+  const blockDataSize = blockSize - blockIDBytes - blockDataSizeBytes;
+  const numEntries = collected.files.length + collected.dirs.length;
+  const numEntryBlocks = Math.ceil(numEntries * Entry.SIZE / blockDataSize);
+  logger.info("num entries:", numEntries);
+  logger.info("num entry blocks:", numEntryBlocks);
+  blocks += numEntryBlocks;
+  for (let f of collected.files) {
+    const size = Math.ceil(f.size / blockDataSize);
+    logger.debug("file:", f.src, "blocks:", size);
+    blocks += size;
+  }
+  const blockIDBytes2 = requiredBytes(blocks);
+  return blockIDBytes2 > blockIDBytes ? computeBlockCount(collected, blockSize, logger, blocks) : blocks;
+};
+const requiredBytes = (x) => align(Math.ceil(Math.log2(x)), 8) >> 3;
+export {
+  CONVERT
+};

package/cli/list.d.ts

@@ -0,0 +1,12 @@
+import { type Command } from "@thi.ng/args";
+import { type AppCtx, type CLIOpts } from "./api.js";
+interface ListOpts extends CLIOpts {
+    blockSize: number;
+    all: boolean;
+    tree: boolean;
+    withMtime: boolean;
+    withSize: boolean;
+}
+export declare const LIST: Command<ListOpts, CLIOpts, AppCtx<ListOpts>>;
+export {};
+//# sourceMappingURL=list.d.ts.map

package/cli/list.js

@@ -0,0 +1,87 @@
+import { flag } from "@thi.ng/args";
+import { compareByKey } from "@thi.ng/compare";
+import { readBinary } from "@thi.ng/file-io";
+import { BlockFS } from "../fs.js";
+import { MemoryBlockStorage } from "../storage/memory.js";
+import { ARG_BLOCKSIZE } from "./api.js";
+const INDENT = ["\u2502   ", "    "];
+const PREFIX = ["\u251C\u2500\u2500 ", "\u2514\u2500\u2500 "];
+const LIST = {
+  opts: {
+    ...ARG_BLOCKSIZE,
+    all: flag({
+      alias: "a",
+      desc: "Display all attribs"
+    }),
+    tree: flag({
+      alias: "t",
+      desc: "List files as tree"
+    }),
+    withMtime: flag({
+      alias: "m",
+      desc: "Display modified times"
+    }),
+    withSize: flag({
+      alias: "s",
+      desc: "Display file sizes"
+    })
+  },
+  desc: "List file tree of a BlockFS blob",
+  fn: async (ctx) => {
+    if (ctx.opts.all) {
+      ctx.opts.withMtime = ctx.opts.withSize = true;
+    }
+    const buffer = readBinary(ctx.inputs[0]);
+    const storage = new MemoryBlockStorage({
+      numBlocks: buffer.length / ctx.opts.blockSize >>> 0,
+      blockSize: ctx.opts.blockSize,
+      logger: ctx.logger,
+      buffer
+    });
+    const bfs = new BlockFS(storage, { logger: ctx.logger });
+    await bfs.init();
+    const tree = [];
+    for await (let entry of bfs.root.tree(compareByKey("name"))) {
+      const path = entry.path;
+      const depth = path.split("/").length - 2;
+      tree.push([path, depth, entry]);
+    }
+    const rows = [];
+    const maxWidths = [0, 0, 0];
+    const last = [];
+    for (let i = 0, num = tree.length - 1; i <= num; i++) {
+      const [path, depth, entry] = tree[i];
+      last[depth] = ~~(i === num);
+      for (let j = i + 1; j <= num; j++) {
+        if (tree[j][1] === depth) break;
+        if (tree[j][1] < depth || j === num) {
+          last[depth] = 1;
+          break;
+        }
+      }
+      const row = ctx.opts.tree ? [
+        [
+          ...last.slice(0, depth).map((x) => INDENT[x]),
+          PREFIX[last[depth]],
+          entry.name
+        ].join("")
+      ] : [path];
+      if (ctx.opts.withSize) {
+        row.push(entry.isDirectory() ? "" : String(Number(entry.size)));
+      }
+      if (ctx.opts.withMtime) {
+        row.push(new Date(entry.mtime).toISOString());
+      }
+      rows.push(row);
+      for (let i2 = 0; i2 < row.length; i2++) {
+        maxWidths[i2] = Math.max(maxWidths[i2], row[i2].length);
+      }
+    }
+    for (let row of rows) {
+      console.log(row.map((x, i) => x.padEnd(maxWidths[i])).join("  "));
+    }
+  }
+};
+export {
+  LIST
+};

package/cli.d.ts

@@ -1,25 +1,2 @@
-import { type Command, type CommandCtx } from "@thi.ng/args";
-interface CLIOpts {
-    verbose: boolean;
-    quiet: boolean;
-}
-interface ConvertOpts extends CLIOpts {
-    numBlocks?: number;
-    blockSize: number;
-    exclude?: string[];
-    include?: string[];
-    out: string;
-}
-interface ListOpts extends CLIOpts {
-    blockSize: number;
-    all: boolean;
-    tree: boolean;
-    withMtime: boolean;
-    withSize: boolean;
-}
-export interface AppCtx<T extends CLIOpts> extends CommandCtx<T, CLIOpts> {
-}
-export declare const CONVERT: Command<ConvertOpts, CLIOpts, AppCtx<ConvertOpts>>;
-export declare const LIST: Command<ListOpts, CLIOpts, AppCtx<ListOpts>>;
 export {};
 //# sourceMappingURL=cli.d.ts.map

package/cli.js

@@ -1,209 +1,10 @@
-import {
-  cliApp,
-  flag,
-  int,
-  string,
-  strings,
-  THING_HEADER
-} from "@thi.ng/args";
-import { align, isPow2 } from "@thi.ng/binary";
-import { illegalArgs } from "@thi.ng/errors";
-import { files, readBinary, readJSON, writeFile } from "@thi.ng/file-io";
+import { cliApp, flag, THING_HEADER } from "@thi.ng/args";
+import { readJSON } from "@thi.ng/file-io";
 import { LogLevel } from "@thi.ng/logger";
-import { statSync } from "node:fs";
-import { join, relative, resolve } from "node:path";
-import { Entry } from "./entry.js";
-import { BlockFS } from "./fs.js";
-import { MemoryBlockStorage } from "./storage/memory.js";
+import { join } from "node:path";
+import { CONVERT } from "./cli/convert.js";
+import { LIST } from "./cli/list.js";
 const PKG = readJSON(join(process.argv[2], "package.json"));
-const ARG_BLOCKSIZE = {
-  blockSize: int({
-    alias: "bs",
-    desc: "Block size",
-    hint: "BYTES",
-    default: 1024,
-    coerce: (x) => {
-      const size = +x;
-      if (!isPow2(size)) illegalArgs("block size must be a power of 2");
-      return size;
-    }
-  })
-};
-const requiredBytes = (x) => align(Math.ceil(Math.log2(x)), 8) >> 3;
-const pathsForFile = (f) => {
-  const parts = f.split("/");
-  const dirs = [];
-  for (let i = 1; i < parts.length; i++)
-    dirs.push(parts.slice(0, i).join("/"));
-  return dirs;
-};
-const collectFiles = ({
-  opts: { include, exclude },
-  inputs
-}) => {
-  const root = resolve(inputs[0]);
-  const filtered = [];
-  const dirs = /* @__PURE__ */ new Set();
-  const $include = include?.map((x) => new RegExp(x));
-  const $exclude = exclude?.map((x) => new RegExp(x));
-  let total = 0;
-  for (let f of files(root)) {
-    const stats = statSync(f);
-    if ($exclude && $exclude.some((x) => x.test(f))) continue;
-    if ($include && !$include.some((x) => x.test(f))) continue;
-    const dest = relative(root, f);
-    filtered.push({
-      src: f,
-      dest,
-      size: stats.size,
-      ctime: stats.ctimeMs,
-      mtime: stats.mtimeMs
-    });
-    for (let d of pathsForFile(dest)) dirs.add(d);
-    total += stats.size;
-  }
-  return { files: filtered, dirs: [...dirs], size: total };
-};
-const computeBlockCount = (collected, blockSize, logger, numBlocks) => {
-  let blocks = collected.dirs.length;
-  const blockIDBytes = requiredBytes(
-    numBlocks ?? collected.size / blockSize + blocks
-  );
-  const blockDataSizeBytes = requiredBytes(blockSize);
-  const blockDataSize = blockSize - blockIDBytes - blockDataSizeBytes;
-  const numEntries = collected.files.length + collected.dirs.length;
-  const numEntryBlocks = Math.ceil(numEntries * Entry.SIZE / blockDataSize);
-  logger.info("num entries:", numEntries);
-  logger.info("num entry blocks:", numEntryBlocks);
-  blocks += numEntryBlocks;
-  for (let f of collected.files) {
-    const size = Math.ceil(f.size / blockDataSize);
-    logger.debug("file:", f.src, "blocks:", size);
-    blocks += size;
-  }
-  const blockIDBytes2 = requiredBytes(blocks);
-  return blockIDBytes2 > blockIDBytes ? computeBlockCount(collected, blockSize, logger, blocks) : blocks;
-};
-const CONVERT = {
-  opts: {
-    ...ARG_BLOCKSIZE,
-    numBlocks: int({
-      alias: "n",
-      desc: "Number of blocks (multiple of 8)",
-      optional: true
-    }),
-    out: string({
-      alias: "o",
-      desc: "Output file path",
-      optional: false
-    }),
-    exclude: strings({
-      alias: "e",
-      desc: "File exclusion regexp",
-      hint: "EXT"
-    }),
-    include: strings({
-      alias: "i",
-      desc: "File inclusion regexp",
-      hint: "EXT"
-    })
-  },
-  desc: "Convert file tree into single BlockFS blob",
-  fn: async (ctx) => {
-    const collected = collectFiles(ctx);
-    const numBlocks = align(
-      ctx.opts.numBlocks ?? computeBlockCount(collected, ctx.opts.blockSize, ctx.logger),
-      8
-    );
-    ctx.logger.info("number of files:", collected.files.length);
-    ctx.logger.info("number of directories:", collected.dirs.length);
-    ctx.logger.info("total file size:", collected.size);
-    ctx.logger.info("number of blocks:", numBlocks);
-    const storage = new MemoryBlockStorage({
-      numBlocks,
-      blockSize: ctx.opts.blockSize,
-      logger: ctx.logger
-    });
-    const bfs = new BlockFS(storage, { logger: ctx.logger });
-    await bfs.init();
-    ctx.logger.info("root dir block:", bfs.rootDirBlockID);
-    ctx.logger.info("first data block:", bfs.dataStartBlockID);
-    ctx.logger.info("block data size:", bfs.blockDataSize);
-    for (let f of collected.files) {
-      const data = readBinary(f.src, ctx.logger);
-      ctx.logger.info("writing file:", f.dest, "size:", data.length);
-      await bfs.writeFile(f.dest, data);
-      const entry = await bfs.entryForPath(f.dest);
-      entry.ctime = f.ctime;
-      entry.mtime = f.mtime;
-      await entry.save();
-    }
-    writeFile(ctx.opts.out, storage.buffer, void 0, ctx.logger);
-  }
-};
-const LIST = {
-  opts: {
-    ...ARG_BLOCKSIZE,
-    all: flag({
-      alias: "a",
-      desc: "Display all attribs"
-    }),
-    tree: flag({
-      alias: "t",
-      desc: "List files as tree"
-    }),
-    withMtime: flag({
-      alias: "m",
-      desc: "Display modified times"
-    }),
-    withSize: flag({
-      alias: "s",
-      desc: "Display file sizes"
-    })
-  },
-  desc: "List file tree of a BlockFS blob",
-  fn: async (ctx) => {
-    if (ctx.opts.all) {
-      ctx.opts.withMtime = ctx.opts.withSize = true;
-    }
-    const buffer = readBinary(ctx.inputs[0]);
-    const storage = new MemoryBlockStorage({
-      numBlocks: buffer.length / ctx.opts.blockSize >>> 0,
-      blockSize: ctx.opts.blockSize,
-      logger: ctx.logger,
-      buffer
-    });
-    const bfs = new BlockFS(storage, { logger: ctx.logger });
-    await bfs.init();
-    const tree = [];
-    for await (let entry of bfs.root.tree()) {
-      const path = entry.path;
-      const depth = path.split("/").length - 2;
-      tree.push([path, depth, entry]);
-    }
-    tree.sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
-    const rows = [];
-    const maxWidths = [0, 0, 0];
-    for (let i = 0, num = tree.length - 1; i <= num; i++) {
-      const f = tree[i];
-      const isLast = i === num || f[1] > tree[i + 1][1];
-      const row = ctx.opts.tree ? ["\u2502   ".repeat(f[1]) + (isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ") + f[2].name] : [f[0]];
-      if (ctx.opts.withSize) {
-        row.push(f[2].isDirectory() ? "" : String(Number(f[2].size)));
-      }
-      if (ctx.opts.withMtime) {
-        row.push(new Date(f[2].mtime).toISOString());
-      }
-      rows.push(row);
-      for (let i2 = 0; i2 < row.length; i2++) {
-        maxWidths[i2] = Math.max(maxWidths[i2], row[i2].length);
-      }
-    }
-    for (let row of rows) {
-      console.log(row.map((x, i) => x.padEnd(maxWidths[i])).join("  "));
-    }
-  }
-};
 cliApp({
   name: "blockfs",
   start: 3,
@@ -240,7 +41,3 @@ Usage: blockfs <cmd> [opts] input [...]
     paramWidth: 32
   }
 });
-export {
-  CONVERT,
-  LIST
-};

package/directory.d.ts

@@ -1,3 +1,4 @@
+import type { Comparator } from "@thi.ng/api";
 import { type EntrySpec, type IDirectory, type IEntry } from "./api.js";
 import type { BlockFS } from "./fs.js";
 export declare class Directory implements IDirectory {
@@ -5,7 +6,7 @@ export declare class Directory implements IDirectory {
     entry: IEntry;
     constructor(fs: BlockFS, entry: IEntry);
     [Symbol.asyncIterator](): AsyncIterableIterator<IEntry>;
-    tree(): AsyncIterableIterator<IEntry>;
+    tree(cmp?: Comparator<IEntry>): AsyncIterableIterator<IEntry>;
     traverse(): Promise<{
         blocks: number[];
         entries: IEntry[];

package/directory.js

@@ -23,10 +23,22 @@ class Directory {
       blockID = next;
     }
   }
-  async *tree() {
-    for await (let entry of this) {
-      yield entry;
-      if (entry.isDirectory()) yield* entry.directory.tree();
+  async *tree(cmp) {
+    if (cmp) {
+      const entries = [];
+      for await (let entry of this) {
+        entries.push(entry);
+      }
+      entries.sort(cmp);
+      for (let entry of entries) {
+        yield entry;
+        if (entry.isDirectory()) yield* entry.directory.tree(cmp);
+      }
+    } else {
+      for await (let entry of this) {
+        yield entry;
+        if (entry.isDirectory()) yield* entry.directory.tree();
+      }
     }
   }
   async traverse() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/block-fs",
-  "version": "0.5.10",
+  "version": "0.6.1",
   "description": "Customizable block-based storage, adapters & file system layer",
   "type": "module",
   "module": "./index.js",
@@ -43,10 +43,11 @@
   },
   "dependencies": {
     "@thi.ng/api": "^8.11.30",
-    "@thi.ng/args": "^2.7.1",
+    "@thi.ng/args": "^2.7.2",
     "@thi.ng/binary": "^3.4.53",
     "@thi.ng/bitfield": "^2.4.6",
     "@thi.ng/checks": "^3.7.10",
+    "@thi.ng/compare": "^2.4.22",
     "@thi.ng/errors": "^2.5.36",
     "@thi.ng/file-io": "^2.2.1",
     "@thi.ng/logger": "^3.1.11",
@@ -91,6 +92,7 @@
     "./*.js",
     "./*.d.ts",
     "bin",
+    "cli",
     "storage"
   ],
   "exports": {
@@ -100,6 +102,15 @@
     "./api": {
       "default": "./api.js"
     },
+    "./cli/api": {
+      "default": "./cli/api.js"
+    },
+    "./cli/convert": {
+      "default": "./cli/convert.js"
+    },
+    "./cli/list": {
+      "default": "./cli/list.js"
+    },
     "./cli": {
       "default": "./cli.js"
     },
@@ -132,5 +143,5 @@
     "status": "alpha",
     "year": 2024
   },
-  "gitHead": "cc6ab918acdac66990d04d6751d19c573a09730d\n"
+  "gitHead": "4d75e2d11a3d1a3c3769ca00338e32a820c69d2c\n"
 }