@thi.ng/block-fs 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2025-04-01T21:42:04Z
+- **Last updated**: 2025-04-02T10:24:13Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.
@@ -11,6 +11,18 @@ 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.2.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/block-fs@0.2.0) (2025-04-02)
+
+#### 🚀 Features
+
+- add path separator option, various refactoring ([875465e](https://github.com/thi-ng/umbrella/commit/875465e))
+  - add `BlockFSOpts.separator`
+  - rename `.readFileRaw()` => `.readBlocks()`
+  - rename `.writeFileRaw()` => `.writeBlocks()`
+  - add additional internal safety checks
+  - internal refactoring (`this` destructuring)
+  - add docs
+
 ## [0.1.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/block-fs@0.1.0) (2025-04-01)
 
 #### 🚀 Features

package/README.md

@@ -53,6 +53,7 @@ The package also provides an hierarchical filesystem layer with pluggable
 storage providers and other customizable aspects. The default implementation
 supports:
 
+- 8 - 32bit block IDs
 - arbitrarily nested directories
 - filenames of max. 31 bytes (UTF-8) per directory level
 - max. 32 owner IDs
@@ -73,6 +74,9 @@ The filesystem stores a [bitfield](https://thi.ng/bitfield) of block allocations
 in the first N blocks. The number of blocks used depends on configured block
 size and the max. number of blocks in the storage backend.
 
+Blocks can be reserved for custom purposes by calling
+[`.allocateBlocks()`](https://docs.thi.ng/umbrella/block-fs/classes/BlockFS.html#allocateblocks).
+
 #### Root directory
 
 The root directory starts in block N, directly after the block allocation table.
@@ -130,7 +134,7 @@ For Node.js REPL:
 const bf = await import("@thi.ng/block-fs");
 ```
 
-Package sizes (brotli'd, pre-treeshake): ESM: 4.11 KB
+Package sizes (brotli'd, pre-treeshake): ESM: 4.32 KB
 
 ## Dependencies
 
@@ -198,7 +202,10 @@ console.log(await fs.readFile("/deeply/nested/paths/are-ok"));
 
 // iterate all files & directory entries in root dir
 for await (let entry of fs.root.tree()) {
-    console.log(entry.type, entry.path, entry.size, new Date(entry.ctime));
+    // entry.path is absolute path
+    // entry.size is always a bigint
+    // entry.ctime/mtime is UNIX epoch
+    console.log(entry.path, entry.size, new Date(entry.ctime));
 }
 
 // /hello 0n 2025-04-01T20:18:55.916Z

package/api.d.ts

@@ -18,18 +18,35 @@ export interface IBlockStorage {
 }
 export interface BlockStorageOpts {
     logger?: ILogger;
+    /**
+     * Max. number of blocks. Will be rounded up to a multiple of 8.
+     */
     numBlocks: number;
+    /**
+     * Block size in bytes. Must be a power of 2. For usage with
+     * {@link BlockFS}, requires a minimum size of 128 bytes (though in practice
+     * should be larger to minimize overhead per block).
+     */
     blockSize: Pow2;
 }
 export interface EntrySpec {
+    /** Entry type (file or directory) */
     type: EntryType;
+    /** TODO currently still unused */
     locked?: boolean;
+    /** Owner ID */
     owner?: number;
+    /** Entry name */
     name: string;
+    /** Only used for files. File size as bigint */
     size?: bigint;
+    /** Entry creation timestamp */
     ctime?: number;
+    /** Entry modification timestamp */
     mtime?: number;
+    /** Data start block ID */
     start: number;
+    /** Data end block ID */
     end?: number;
 }
 export declare enum EntryType {

package/directory.js

@@ -30,18 +30,22 @@ class Directory {
     }
   }
   async traverse() {
+    const {
+      fs,
+      fs: { sentinelID, storage }
+    } = this;
     const blocks = [];
     const entries = [];
     let blockID = this.entry.start;
     while (true) {
       blocks.push(blockID);
-      const block = await this.fs.storage.loadBlock(blockID);
-      let { next, size } = this.fs.getBlockMeta(block);
-      if (!next) next = this.fs.sentinelID;
+      const block = await storage.loadBlock(blockID);
+      let { next, size } = fs.getBlockMeta(block);
+      if (!next) next = sentinelID;
       for (let i = 0; i < size; i++) {
         entries.push(this.defEntry(i, blockID, block));
       }
-      if (next === this.fs.sentinelID) break;
+      if (next === sentinelID) break;
       blockID = next;
     }
     return { blocks, entries };
@@ -52,16 +56,17 @@ class Directory {
     }
   }
   async mkdir(name) {
+    const fs = this.fs;
     const length = utf8Length(name);
-    if (!length || length > this.fs.opts.entry.maxLength)
+    if (!length || length > fs.opts.entry.maxLength)
       illegalArgs(`invalid name: '${name}'`);
     const traversed = await this.traverse();
     this.ensureUniqueName(name, traversed.entries);
-    const block = (await this.fs.allocateBlocks(1))[0];
-    const data = await this.fs.storage.loadBlock(block);
-    this.fs.setBlockMeta(data, this.fs.sentinelID, 0);
-    this.fs.setBlockLink(data, this.entry.start, this.fs.dataStartBlockID);
-    await this.fs.storage.saveBlock(block, data);
+    const block = (await fs.allocateBlocks(1))[0];
+    const data = await fs.storage.loadBlock(block);
+    fs.setBlockMeta(data, fs.sentinelID, 0);
+    fs.setBlockLink(data, this.entry.start, fs.dataStartBlockID);
+    await fs.storage.saveBlock(block, data);
     return this.addEntry(
       {
         name,

package/entry.js

@@ -124,7 +124,7 @@ class Entry {
       path.unshift(entry.name);
       entry = entry.parent?.entry;
     }
-    return path.join("/");
+    return path.join(this.fs.opts.separator);
   }
   /**
    * Returns {@link IDirectory} wrapper for this entry (only if a directory,

package/fs.d.ts

@@ -3,6 +3,15 @@ import type { ILogger } from "@thi.ng/logger";
 import { EntryType, type IBlockStorage, type IDirectory, type IEntry } from "./api.js";
 import { Lock } from "./lock.js";
 export interface BlockFSOpts {
+    /**
+     * Path separator.
+     *
+     * @defaultValue `/`
+     */
+    separator: string;
+    /**
+     * Logger instance to use.
+     */
     logger: ILogger;
     /**
      * Customizable {@link IDirectory} factory function. By default creates
@@ -66,16 +75,99 @@ export declare class BlockFS {
     root: IDirectory;
     constructor(storage: IBlockStorage, opts?: Partial<BlockFSOpts>);
     init(): Promise<this>;
+    /**
+     * Attempts to find the {@link IEntry} for given `path` and returns it if
+     * successful. Throws error if no such path exists.
+     *
+     * @remarks
+     * Also see {@link BlockFS.ensureEntryForPath}.
+     *
+     * @param path
+     */
     entryForPath(path: string): Promise<IEntry>;
+    /**
+     * Attempts to find or to create the {@link IEntry} for given `path` and
+     * entry type (file or directory) and then returns it if successful. Throws
+     * error if the path exists, but does not match the expected type or if the
+     * entry could not be created for other reasons.
+     *
+     * @remarks
+     * Also see {@link BlockFS.entryForPath}.
+     *
+     * @param path
+     * @param type
+     */
     ensureEntryForPath(path: string, type: EntryType): Promise<IEntry>;
+    /**
+     * Attempts to allocate a number of free blocks required for storing the
+     * given number of `bytes`. If successful, marks the blocks as used in the
+     * allocation table and then returns list of their IDs, otherwise throws an
+     * error if there're insufficient blocks available.
+     *
+     * @param bytes
+     */
     allocateBlocks(bytes: number): Promise<number[]>;
+    /**
+     * Marks the given block IDs as free/unused in the block allocation table
+     * and deletes/clears the blocks.
+     *
+     * @param ids
+     */
     freeBlocks(ids: number[]): Promise<void>;
+    /**
+     * Same as POSIX `mkdirp`. Attempts to create given directory, including any
+     * missing intermediate ones defined by `path`.
+     *
+     * @param path
+     */
     mkdir(path: string): Promise<IEntry>;
-    readFileRaw(path: string | number): AsyncGenerator<Uint8Array<ArrayBufferLike>, void, unknown>;
+    /**
+     * Async iterator. Reads block list for given `path` (file path or start
+     * block ID) and yields data contents (byte arrays) of each block.
+     *
+     * @remarks
+     * Also see other read methods:
+     *
+     * - {@link BlockFS.readFile}
+     * - {@link BlockFS.readText}
+     * - {@link BlockFS.readJSON}
+     *
+     * @param path
+     */
+    readBlocks(path: string | number): AsyncGenerator<Uint8Array<ArrayBufferLike>, void, unknown>;
+    /**
+     * Fully reads given file into a single byte buffer and returns it.
+     *
+     * @param path
+     */
     readFile(path: string | number): Promise<Uint8Array<ArrayBuffer>>;
+    /**
+     * Fully reads given file into a single UTF-8 byte buffer, then decodes and
+     * returns it as string.
+     *
+     * @param path
+     */
     readText(path: string | number): Promise<string>;
-    readJSON(path: string | number): Promise<any>;
-    writeFileRaw(blocks: number[] | null, data: Uint8Array): Promise<{
+    /**
+     * Fully reads given file into a single UTF-8 byte buffer, then decodes it
+     * as JSON and returns result.
+     *
+     * @param path
+     */
+    readJSON<T>(path: string | number): Promise<T>;
+    /**
+     * Takes an array of block IDs (or `null`) and a `data` byte array. Writes
+     * chunks of data into given blocks and connecting each block as linked
+     * list. Returns object of start/end block IDs and data size.
+     *
+     * @remarks
+     * If `blocks` is null, blocks are automatically allocated via
+     * {@link BlockFS.allocateBlocks}.
+     *
+     * @param blocks
+     * @param data
+     */
+    writeBlocks(blocks: number[] | null, data: Uint8Array): Promise<{
         start: number;
         end: number;
         size: number;
@@ -85,7 +177,7 @@ export declare class BlockFS {
         end: number;
         size: number;
     }>;
-    appendFileRaw(blockID: number, data: Uint8Array): Promise<{
+    appendBlocks(blockID: number, data: Uint8Array): Promise<{
         start: number;
         end: number;
         size: number;

package/fs.js

@@ -3,6 +3,7 @@ import { defBitField } from "@thi.ng/bitfield/bitfield";
 import { isString } from "@thi.ng/checks/is-string";
 import { assert } from "@thi.ng/errors/assert";
 import { illegalArgs } from "@thi.ng/errors/illegal-arguments";
+import { illegalState } from "@thi.ng/errors/illegal-state";
 import { NULL_LOGGER } from "@thi.ng/logger/null";
 import {
   EntryType
@@ -22,9 +23,10 @@ class BlockFS {
   constructor(storage, opts) {
     this.storage = storage;
     this.opts = {
-      logger: NULL_LOGGER,
       directory: (fs, entry) => new Directory(fs, entry),
       entry: DEFAULT_ENTRY,
+      logger: NULL_LOGGER,
+      separator: "/",
       ...opts
     };
     assert(
@@ -67,60 +69,84 @@ class BlockFS {
   /** Root directory */
   root;
   async init() {
-    const indexSize = this.blockIndex.data.length;
-    const blockSize = this.storage.blockSize;
-    for (let i = 0; i < this.rootDirBlockID; i++) {
-      const data = await this.storage.loadBlock(i);
+    const { blockIndex, storage, opts, rootDirBlockID } = this;
+    const indexSize = blockIndex.data.length;
+    const blockSize = storage.blockSize;
+    for (let i = 0; i < rootDirBlockID; i++) {
+      const data = await storage.loadBlock(i);
       const offset = i * blockSize;
       if (offset + data.length > indexSize) {
-        this.blockIndex.data.set(
+        blockIndex.data.set(
           data.subarray(0, indexSize - offset),
           offset
         );
       } else {
-        this.blockIndex.data.set(data, offset);
+        blockIndex.data.set(data, offset);
       }
     }
-    this.blockIndex.fill(1, 0, this.dataStartBlockID);
-    const rootEntry = this.opts.entry.factory(
+    blockIndex.fill(1, 0, this.dataStartBlockID);
+    const rootEntry = opts.entry.factory(
       this,
       null,
-      this.rootDirBlockID,
-      new Uint8Array(this.opts.entry.size),
+      rootDirBlockID,
+      new Uint8Array(opts.entry.size),
       0
     );
     rootEntry.set({
       name: "",
       type: EntryType.DIR,
-      start: this.rootDirBlockID,
+      start: rootDirBlockID,
       owner: 0
     });
-    this.root = this.opts.directory(this, rootEntry);
+    this.root = opts.directory(this, rootEntry);
     return this;
   }
+  /**
+   * Attempts to find the {@link IEntry} for given `path` and returns it if
+   * successful. Throws error if no such path exists.
+   *
+   * @remarks
+   * Also see {@link BlockFS.ensureEntryForPath}.
+   *
+   * @param path
+   */
   async entryForPath(path) {
     let dir = this.root;
-    if (path[0] === "/") path = path.substring(1);
+    const { directory, separator } = this.opts;
+    if (path[0] === separator) path = path.substring(1);
     if (path === "") return dir.entry;
-    const $path = path.split("/");
-    for (let i = 0; i < $path.length; i++) {
+    const $path = path.split(separator);
+    for (let i = 0, len = $path.length - 1; i <= len; i++) {
       let entry = await dir.findName($path[i]);
       if (!entry) break;
-      if (i === $path.length - 1) return entry;
+      if (i === len) return entry;
       if (!entry.isDirectory()) illegalArgs(path);
-      dir = this.opts.directory(this, entry);
+      dir = directory(this, entry);
     }
     illegalArgs(path);
   }
+  /**
+   * Attempts to find or to create the {@link IEntry} for given `path` and
+   * entry type (file or directory) and then returns it if successful. Throws
+   * error if the path exists, but does not match the expected type or if the
+   * entry could not be created for other reasons.
+   *
+   * @remarks
+   * Also see {@link BlockFS.entryForPath}.
+   *
+   * @param path
+   * @param type
+   */
   async ensureEntryForPath(path, type) {
     let dir = this.root;
-    if (path[0] === "/") path = path.substring(1);
+    const { directory, separator } = this.opts;
+    if (path[0] === separator) path = path.substring(1);
     if (path === "") return dir.entry;
-    const $path = path.split("/");
-    for (let i = 0; i < $path.length; i++) {
+    const $path = path.split(separator);
+    for (let i = 0, len = $path.length - 1; i <= len; i++) {
       let entry = await dir.findName($path[i]);
       if (!entry) {
-        if (i < $path.length - 1) {
+        if (i < len) {
           entry = await dir.mkdir($path[i]);
         } else {
           return await dir.addEntry({
@@ -130,7 +156,7 @@ class BlockFS {
           });
         }
       }
-      if (i === $path.length - 1) {
+      if (i === len) {
         if (entry.type !== type)
           illegalArgs(
             `path exists, but is not a ${EntryType[type]}: ${path}`
@@ -138,32 +164,53 @@ class BlockFS {
         return entry;
       }
       if (!entry.isDirectory()) illegalArgs(path);
-      dir = this.opts.directory(this, entry);
+      dir = directory(this, entry);
     }
     illegalArgs(path);
   }
+  /**
+   * Attempts to allocate a number of free blocks required for storing the
+   * given number of `bytes`. If successful, marks the blocks as used in the
+   * allocation table and then returns list of their IDs, otherwise throws an
+   * error if there're insufficient blocks available.
+   *
+   * @param bytes
+   */
   async allocateBlocks(bytes) {
-    const lockID = await this.lock.acquire();
+    const {
+      blockDataSize,
+      blockIndex,
+      dataStartBlockID,
+      lock,
+      sentinelID
+    } = this;
+    const lockID = await lock.acquire();
     try {
       const ids = [];
-      let last = this.dataStartBlockID;
+      let last = dataStartBlockID;
       while (bytes > 0) {
-        const next = this.blockIndex.firstZero(last);
-        if (next < 0 || next >= this.sentinelID) {
+        const next = blockIndex.firstZero(last);
+        if (next < 0 || next >= sentinelID) {
           throw new Error(
             `insufficient free blocks for storing ${bytes} bytes`
           );
         }
         ids.push(next);
         last = next + 1;
-        bytes -= this.blockDataSize;
+        bytes -= blockDataSize;
       }
       await this.updateBlockIndex(ids, 1);
       return ids;
     } finally {
-      await this.lock.release(lockID);
+      await lock.release(lockID);
     }
   }
+  /**
+   * Marks the given block IDs as free/unused in the block allocation table
+   * and deletes/clears the blocks.
+   *
+   * @param ids
+   */
   async freeBlocks(ids) {
     const lockID = await this.lock.acquire();
     try {
@@ -173,54 +220,99 @@ class BlockFS {
       await this.lock.release(lockID);
     }
   }
+  /**
+   * Same as POSIX `mkdirp`. Attempts to create given directory, including any
+   * missing intermediate ones defined by `path`.
+   *
+   * @param path
+   */
   async mkdir(path) {
     return this.ensureEntryForPath(path, EntryType.DIR);
   }
-  async *readFileRaw(path) {
+  /**
+   * Async iterator. Reads block list for given `path` (file path or start
+   * block ID) and yields data contents (byte arrays) of each block.
+   *
+   * @remarks
+   * Also see other read methods:
+   *
+   * - {@link BlockFS.readFile}
+   * - {@link BlockFS.readText}
+   * - {@link BlockFS.readJSON}
+   *
+   * @param path
+   */
+  async *readBlocks(path) {
     let blockID = isString(path) ? (await this.entryForPath(path)).start : path;
+    const { blockDataOffset, blockIndex, sentinelID, storage } = this;
     while (true) {
-      if (!this.blockIndex.at(blockID)) {
+      if (!blockIndex.at(blockID)) {
         throw new Error(`invalid block ref: ${blockID}`);
       }
-      const bytes = await this.storage.loadBlock(blockID);
+      const bytes = await storage.loadBlock(blockID);
       const { next, size } = this.getBlockMeta(bytes);
-      yield bytes.subarray(
-        this.blockDataOffset,
-        this.blockDataOffset + size
-      );
-      if (next === this.sentinelID) return;
+      yield bytes.subarray(blockDataOffset, blockDataOffset + size);
+      if (next === sentinelID) return;
       blockID = next;
     }
   }
+  /**
+   * Fully reads given file into a single byte buffer and returns it.
+   *
+   * @param path
+   */
   async readFile(path) {
     const buffer = [];
-    for await (let block of this.readFileRaw(path)) buffer.push(...block);
+    for await (let block of this.readBlocks(path)) buffer.push(...block);
     return new Uint8Array(buffer);
   }
+  /**
+   * Fully reads given file into a single UTF-8 byte buffer, then decodes and
+   * returns it as string.
+   *
+   * @param path
+   */
   async readText(path) {
     return new TextDecoder().decode(await this.readFile(path));
   }
+  /**
+   * Fully reads given file into a single UTF-8 byte buffer, then decodes it
+   * as JSON and returns result.
+   *
+   * @param path
+   */
   async readJSON(path) {
     return JSON.parse(await this.readText(path));
   }
-  async writeFileRaw(blocks, data) {
+  /**
+   * Takes an array of block IDs (or `null`) and a `data` byte array. Writes
+   * chunks of data into given blocks and connecting each block as linked
+   * list. Returns object of start/end block IDs and data size.
+   *
+   * @remarks
+   * If `blocks` is null, blocks are automatically allocated via
+   * {@link BlockFS.allocateBlocks}.
+   *
+   * @param blocks
+   * @param data
+   */
+  async writeBlocks(blocks, data) {
+    const { blockDataOffset, blockDataSize, sentinelID, storage } = this;
     if (!blocks) blocks = await this.allocateBlocks(data.length);
     let offset = 0;
     for (let i = 0, numBlocks = blocks.length - 1; i <= numBlocks; i++) {
+      if (offset >= data.length)
+        illegalState(`too many blocks, EOF already reached`);
       const id = blocks[i];
-      const block = await this.storage.loadBlock(id);
-      i < numBlocks ? this.setBlockMeta(block, blocks[i + 1], this.blockDataSize) : this.setBlockMeta(
-        block,
-        this.sentinelID,
-        data.length - offset
-      );
-      const chunk = data.subarray(offset, offset + this.blockDataSize);
-      block.set(chunk, this.blockDataOffset);
-      if (chunk.length < this.blockDataSize) {
-        block.fill(0, this.blockDataOffset + chunk.length);
+      const block = await storage.loadBlock(id);
+      i < numBlocks ? this.setBlockMeta(block, blocks[i + 1], blockDataSize) : this.setBlockMeta(block, sentinelID, data.length - offset);
+      const chunk = data.subarray(offset, offset + blockDataSize);
+      block.set(chunk, blockDataOffset);
+      if (chunk.length < blockDataSize) {
+        block.fill(0, blockDataOffset + chunk.length);
       }
-      await this.storage.saveBlock(id, block);
-      offset += this.blockDataSize;
+      await storage.saveBlock(id, block);
+      offset += blockDataSize;
     }
     return {
       start: blocks[0],
@@ -230,7 +322,7 @@ class BlockFS {
   }
   async writeFile(path, data) {
     if (isString(data)) data = new TextEncoder().encode(data);
-    if (!path) return this.writeFileRaw(null, data);
+    if (!path) return this.writeBlocks(null, data);
     const entry = await this.ensureEntryForPath(path, EntryType.FILE);
     let blocks = await this.blockList(entry.start);
     const overflow = data.length - blocks.length * this.blockDataSize;
@@ -241,37 +333,38 @@ class BlockFS {
       await this.freeBlocks(blocks.slice(needed));
       blocks = blocks.slice(0, needed);
     }
-    blocks.sort();
+    blocks.sort((a, b) => a - b);
     entry.start = blocks[0];
     entry.end = blocks[blocks.length - 1];
     entry.size = BigInt(data.length);
     entry.mtime = Date.now();
     await entry.save();
-    return this.writeFileRaw(blocks, data);
+    return this.writeBlocks(blocks, data);
   }
-  async appendFileRaw(blockID, data) {
-    if (blockID === this.sentinelID) return this.writeFileRaw(null, data);
+  async appendBlocks(blockID, data) {
+    if (blockID === this.sentinelID) return this.writeBlocks(null, data);
+    const { blockDataOffset, blockDataSize, storage } = this;
     const blocks = await this.blockList(blockID);
     const lastBlockID = blocks[blocks.length - 1];
-    const lastBlock = await this.storage.loadBlock(lastBlockID);
+    const lastBlock = await storage.loadBlock(lastBlockID);
     const currLength = decodeBytes(
       lastBlock,
       this.blockIDBytes,
       this.blockDataSizeBytes
     );
-    const remaining = this.blockDataSize - currLength;
-    lastBlock.fill(0, 0, this.blockDataOffset);
+    const remaining = blockDataSize - currLength;
+    lastBlock.fill(0, 0, blockDataOffset);
     lastBlock.set(
       data.subarray(0, remaining),
-      this.blockDataOffset + currLength
+      blockDataOffset + currLength
     );
     let newEndBlockID;
     if (data.length > remaining) {
-      const { start, end } = await this.writeFileRaw(
+      const { start, end } = await this.writeBlocks(
         null,
         data.subarray(remaining)
       );
-      this.setBlockMeta(lastBlock, start, this.blockDataSize);
+      this.setBlockMeta(lastBlock, start, blockDataSize);
       newEndBlockID = end;
     } else {
       this.setBlockMeta(
@@ -281,14 +374,14 @@ class BlockFS {
       );
       newEndBlockID = lastBlockID;
     }
-    await this.storage.saveBlock(lastBlockID, lastBlock);
+    await storage.saveBlock(lastBlockID, lastBlock);
     return { start: blockID, end: newEndBlockID };
   }
   async appendFile(path, data) {
     if (isString(data)) data = new TextEncoder().encode(data);
-    if (!isString(path)) return this.appendFileRaw(path, data);
+    if (!isString(path)) return this.appendBlocks(path, data);
     const entry = await this.ensureEntryForPath(path, EntryType.FILE);
-    const { start, end } = await this.appendFileRaw(entry.end, data);
+    const { start, end } = await this.appendBlocks(entry.end, data);
     if (entry.start === this.sentinelID) entry.start = start;
     entry.end = end;
     entry.size += BigInt(data.length);
@@ -308,33 +401,35 @@ class BlockFS {
     }
   }
   async blockList(blockID) {
+    const { blockIDBytes, sentinelID, storage } = this;
     const blocks = [];
-    if (blockID === this.sentinelID) return blocks;
+    if (blockID === sentinelID) return blocks;
     while (true) {
       blocks.push(blockID);
-      const block = await this.storage.loadBlock(blockID);
-      const nextID = decodeBytes(block, 0, this.blockIDBytes);
-      if (nextID === this.sentinelID) break;
+      const block = await storage.loadBlock(blockID);
+      const nextID = decodeBytes(block, 0, blockIDBytes);
+      if (nextID === sentinelID) break;
       blockID = nextID;
     }
     return blocks;
   }
   async updateBlockIndex(ids, state) {
-    const blockSize = this.storage.blockSize;
+    const { blockIndex, storage, tmp } = this;
+    const blockSize = storage.blockSize;
     const updatedBlocks = /* @__PURE__ */ new Set();
     for (let id of ids) {
-      this.blockIndex.setAt(id, state);
+      blockIndex.setAt(id, state);
       updatedBlocks.add((id >>> 3) / blockSize | 0);
     }
     for (let id of updatedBlocks) {
       this.opts.logger.debug("update block index", id);
-      const chunk = this.blockIndex.data.subarray(
+      const chunk = blockIndex.data.subarray(
         id * blockSize,
         (id + 1) * blockSize
       );
-      this.tmp.set(chunk);
-      if (chunk.length < blockSize) this.tmp.fill(0, chunk.length);
-      await this.storage.saveBlock(id, this.tmp);
+      tmp.set(chunk);
+      if (chunk.length < blockSize) tmp.fill(0, chunk.length);
+      await storage.saveBlock(id, tmp);
     }
   }
   /** @internal */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/block-fs",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Customizable block-based storage, adapters & file system layer",
   "type": "module",
   "module": "./index.js",
@@ -118,5 +118,5 @@
     "status": "alpha",
     "year": 2024
   },
-  "gitHead": "87aa2d0e64a357476c10fd57aabdfded13c79f7d\n"
+  "gitHead": "de166de7bb358998c797090a49bf55bcb7c325ba\n"
 }