@hugomrdias/commp-wasm 0.1.1 → 0.1.2

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.1.2](https://github.com/hugomrdias/commp/compare/commp-wasm-v0.1.1...commp-wasm-v0.1.2) (2026-10-01)
+
+
+### Bug Fixes
+
+* publish type declarations generated from JSDoc ([#32](https://github.com/hugomrdias/commp/issues/32)) ([4b7654e](https://github.com/hugomrdias/commp/commit/4b7654e9f793477f2b237f826bfdbdb937d56d98))
+
 ## [0.1.1](https://github.com/hugomrdias/commp/compare/commp-wasm-v0.1.0...commp-wasm-v0.1.1) (2026-09-30)
 
 

package/dist/index.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Fast CommP (Filecoin Piece Commitment) WASM implementation
+ *
+ * This module provides a high-performance CommP calculation using
+ * Rust/WASM with inline base64 encoding - no async init required.
+ *
+ * @module @hugomrdias/commp-wasm
+ */
+export type PieceDigest = import('./types.js').PieceDigest;
+export type StreamingHasher = import('./types.js').StreamingHasher;
+/** Multihash code for fr32-sha2-256-trunc254-padded-binary-tree */
+export declare const code = 4113;
+/** Multihash name */
+export declare const name: 'fr32-sha2-256-trunc254-padded-binary-tree';
+/**
+ * Streaming CommP hasher
+ *
+ * @example
+ * ```ts twoslash
+ * import { create } from '@hugomrdias/commp-wasm'
+ *
+ * const hasher = create()
+ * hasher.write(new Uint8Array(1024).fill(0x42))
+ * hasher.write(new Uint8Array(1024).fill(0x43))
+ * const digest = hasher.digest()
+ * console.log(digest.root) // 32-byte root hash
+ * ```
+ *
+ * @implements {StreamingHasher}
+ */
+declare class Hasher implements StreamingHasher {
+    #private;
+    /**
+     * Get the total number of bytes written
+     *
+     * @returns {bigint}
+     */
+    count(): bigint;
+    /**
+     * Write bytes into the hasher
+     *
+     * @param {Uint8Array} bytes - Bytes to write
+     * @returns {this}
+     * @throws {RangeError} If the total would exceed `MAX_PAYLOAD_SIZE`; the
+     * hasher is left unchanged
+     */
+    write(bytes: Uint8Array): this;
+    /**
+     * Compute the digest
+     *
+     * @returns {PieceDigest}
+     */
+    digest(): PieceDigest;
+    /**
+     * Reset the hasher to initial state
+     *
+     * @returns {this}
+     */
+    reset(): this;
+    /**
+     * Dispose of resources
+     */
+    dispose(): void;
+    /**
+     * Free WASM resources (alias for dispose)
+     */
+    free(): void;
+}
+/**
+ * Creates a new streaming CommP hasher
+ *
+ * @example
+ * ```ts twoslash
+ * import { create, digest } from '@hugomrdias/commp-wasm'
+ *
+ * // Streaming API
+ * const hasher = create()
+ * hasher.write(chunk1)
+ * hasher.write(chunk2)
+ * const result = hasher.digest()
+ *
+ * // One-shot API
+ * const result2 = digest(fullData)
+ * ```
+ *
+ * @returns {Hasher}
+ */
+export declare function create(): Hasher;
+/**
+ * Computes CommP digest of a complete payload (one-shot)
+ *
+ * @example
+ * ```ts twoslash
+ * import { digest } from '@hugomrdias/commp-wasm'
+ *
+ * const data = new Uint8Array(1024 * 1024).fill(0x42)
+ * const result = digest(data)
+ * console.log(result.root) // 32-byte piece commitment
+ * ```
+ *
+ * @param {Uint8Array} payload - Data to compute CommP for
+ * @returns {PieceDigest}
+ */
+export declare function digest(payload: Uint8Array): PieceDigest;
+/**
+ * Computes just the 32-byte root hash (faster, less allocations)
+ *
+ * @example
+ * ```ts twoslash
+ * import { root } from '@hugomrdias/commp-wasm'
+ *
+ * const data = new Uint8Array(1024 * 1024).fill(0x42)
+ * const rootHash = root(data)
+ * console.log(rootHash) // 32-byte Uint8Array
+ * ```
+ *
+ * @param {Uint8Array} payload - Data to compute CommP for
+ * @returns {Uint8Array}
+ */
+export declare function root(payload: Uint8Array): Uint8Array;
+export declare const NODE_SIZE = 32;
+export declare const IN_BYTES_PER_QUAD = 127;
+export declare const MIN_PAYLOAD_SIZE = 65;
+/**
+ * Largest payload accepted, in bytes: 127 * 2^47 (~15.9 PiB)
+ *
+ * data-segment allows up to tree height 255, far beyond 64 bits. This is the
+ * largest payload for which every derived size (padding, piece size) stays
+ * below 2^53, so the digest fields are exact as JS numbers.
+ */
+export declare const MAX_PAYLOAD_SIZE: bigint;
+export declare const HEIGHT_SIZE = 1;
+export declare const ROOT_SIZE = 32;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMA,YAA4C,WAAW,GAA7C,OAAO,YAAY,EAAE,WAAW,CAAa;AACvD,YAAgD,eAAe,GAArD,OAAO,YAAY,EAAE,eAAe,CAAiB;AASlE,mEAAmE;AACnE,eAAO,MAAM,IAAI,OAAS,CAAA;AAE1B,qBAAqB;AACrB,eAAO,MAAM,IAAI,EACf,2CACD,CAAA;AAED;;;;;;;;;;;;;;;GAeG;AACH,cAAM,MAAM,AAFI,YAAA,eAAe;;IAK7B;;;;OAIG;IACH,KAAK,IAFQ,MAAM,CAIlB;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,KAAK,EALA,UAKA,GAJE,IAAI,CAmBhB;IAED;;;;OAIG;IACH,MAAM,IAFO,WAAW,CAmBvB;IAED;;;;OAIG;IACH,KAAK,IAFQ,IAAI,CAKhB;IAED;;OAEG;IACH,OAAO,SAEN;IAED;;OAEG;IACH,IAAI,SAEH;CACF;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,MAAM,IAFT,MAAM,CAIlB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,MAAM,CAAC,OAAO,EAHnB,UAGmB,GAFjB,WAAW,CASvB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,IAAI,CAAC,OAAO,EAHjB,UAGiB,GAFf,UAAU,CAetB;AAGD,eAAO,MAAM,SAAS,KAAK,CAAA;AAC3B,eAAO,MAAM,iBAAiB,MAAM,CAAA;AACpC,eAAO,MAAM,gBAAgB,KAAK,CAAA;AAElC;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,QAAc,CAAA;AAC3C,eAAO,MAAM,WAAW,IAAI,CAAA;AAC5B,eAAO,MAAM,SAAS,KAAK,CAAA"}

package/dist/types.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Type definitions for CommP WASM implementation
+ */
+/** Streaming hasher interface */
+export interface StreamingHasher {
+    /** Write bytes into the hasher */
+    write(bytes: Uint8Array): this;
+    /** Get the total bytes written */
+    count(): bigint;
+    /** Compute the digest without consuming the hasher */
+    digest(): PieceDigest;
+    /** Reset the hasher to initial state */
+    reset(): this;
+    /** Free resources */
+    dispose(): void;
+    /** Free WASM resources (alias for dispose) */
+    free(): void;
+}
+/** Piece digest result */
+export interface PieceDigest {
+    /** Multihash code */
+    code: 0x1011;
+    /** Multihash name */
+    name: 'fr32-sha2-256-trunc254-padded-binary-tree';
+    /** Raw digest bytes (padding + height + root) */
+    digest: Uint8Array;
+    /** Full multihash bytes (code + size + digest) */
+    bytes: Uint8Array;
+    /** Tree height */
+    height: number;
+    /** 32-byte root hash */
+    root: Uint8Array;
+    /** Zero padding applied */
+    padding: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,iCAAiC;AACjC,MAAM,WAAW,eAAe;IAC9B,kCAAkC;IAClC,KAAK,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,CAAA;IAC9B,kCAAkC;IAClC,KAAK,IAAI,MAAM,CAAA;IACf,sDAAsD;IACtD,MAAM,IAAI,WAAW,CAAA;IACrB,wCAAwC;IACxC,KAAK,IAAI,IAAI,CAAA;IACb,qBAAqB;IACrB,OAAO,IAAI,IAAI,CAAA;IACf,8CAA8C;IAC9C,IAAI,IAAI,IAAI,CAAA;CACb;AAED,0BAA0B;AAC1B,MAAM,WAAW,WAAW;IAC1B,qBAAqB;IACrB,IAAI,EAAE,MAAM,CAAA;IACZ,qBAAqB;IACrB,IAAI,EAAE,2CAA2C,CAAA;IACjD,iDAAiD;IACjD,MAAM,EAAE,UAAU,CAAA;IAClB,kDAAkD;IAClD,KAAK,EAAE,UAAU,CAAA;IACjB,kBAAkB;IAClB,MAAM,EAAE,MAAM,CAAA;IACd,wBAAwB;IACxB,IAAI,EAAE,UAAU,CAAA;IAChB,2BAA2B;IAC3B,OAAO,EAAE,MAAM,CAAA;CAChB"}

package/dist/varint.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Unsigned varint (LEB128) decoding
+ *
+ * Uses arithmetic instead of 32-bit bitwise operators so values up to
+ * `Number.MAX_SAFE_INTEGER` decode correctly.
+ *
+ * @module
+ */
+/**
+ * Decodes a varint from the buffer at the given offset
+ *
+ * @param {Uint8Array} buf - Buffer to read from
+ * @param {number} offset - Offset to start reading
+ * @returns {[value: number, length: number]} - Decoded value and bytes read
+ */
+export declare function decode(buf: Uint8Array, offset: number): [value: number, length: number];
+//# sourceMappingURL=varint.d.ts.map

package/dist/varint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"varint.d.ts","sourceRoot":"","sources":["../src/varint.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAJf,UAIe,EAAE,MAAM,EAHvB,MAGuB,GAFrB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAa3C"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hugomrdias/commp-wasm",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Fast CommP (Filecoin Piece Commitment) WASM implementation with inline base64",
   "keywords": [
     "filecoin",
@@ -18,28 +18,31 @@
   },
   "type": "module",
   "main": "./src/index.js",
-  "types": "./src/types.ts",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./src/types.ts",
+      "types": "./dist/index.d.ts",
       "import": "./src/index.js"
     }
   },
   "files": [
     "src",
+    "dist",
     "CHANGELOG.md"
   ],
   "devDependencies": {
-    "@hugomrdias/commp-js": "0.1.0",
+    "@hugomrdias/commp-js": "0.1.1",
     "@web3-storage/data-segment": "^5.3.0",
-    "mocha": "^12.0.2"
+    "mocha": "^12.0.2",
+    "typescript": "^7.0.2"
   },
   "scripts": {
+    "build": "tsc -p tsconfig.json",
     "build:rust": "cd ../../rs/commp && RUSTFLAGS=\"-C target-feature=+simd128 --remap-path-prefix=${CARGO_HOME:-$HOME/.cargo}=/cargo\" wasm-pack build --target bundler --out-dir ../../packages/commp-wasm/pkg-bundler --release",
     "build:inline": "node scripts/build-inline-wasm.js",
     "build:wasm": "pnpm build:rust && pnpm build:inline",
-    "clean": "rm -rf pkg-bundler",
-    "test": "mocha \"tests/**/*.test.js\"",
+    "clean": "rm -rf pkg-bundler dist",
+    "test": "tsc -p tests && mocha \"tests/**/*.test.js\"",
     "lint": "biome check ."
   }
 }

package/src/index.js

@@ -10,7 +10,10 @@
 import { CommPHasher as WasmHasher, root as wasmRoot } from './inline/commp.js'
 import { decode as varintDecode } from './varint.js'
 
-/** @import { PieceDigest, StreamingHasher } from './types.js' */
+/**
+ * @typedef {import('./types.js').PieceDigest} PieceDigest
+ * @typedef {import('./types.js').StreamingHasher} StreamingHasher
+ */
 
 /**
  * Largest slice passed to WASM per call. wasm-bindgen copies each input into
@@ -43,13 +46,7 @@ export const name = /** @type {const} */ (
  * @implements {StreamingHasher}
  */
 class Hasher {
-  constructor() {
-    /**
-     * @private
-     * @type {WasmHasher}
-     */
-    this.inner = new WasmHasher()
-  }
+  #inner = new WasmHasher()
 
   /**
    * Get the total number of bytes written
@@ -57,7 +54,7 @@ class Hasher {
    * @returns {bigint}
    */
   count() {
-    return BigInt(this.inner.count())
+    return BigInt(this.#inner.count())
   }
 
   /**
@@ -80,7 +77,7 @@ class Hasher {
       )
     }
     for (let offset = 0; offset < bytes.length; offset += CHUNK_SIZE) {
-      this.inner.write(bytes.subarray(offset, offset + CHUNK_SIZE))
+      this.#inner.write(bytes.subarray(offset, offset + CHUNK_SIZE))
     }
     return this
   }
@@ -92,7 +89,7 @@ class Hasher {
    */
   digest() {
     // Format: code (varint) | size (varint) | padding (varint) | height | root
-    const bytes = this.inner.digest()
+    const bytes = this.#inner.digest()
     const [, codeLength] = varintDecode(bytes, 0)
     const [, sizeLength] = varintDecode(bytes, codeLength)
     const digestStart = codeLength + sizeLength
@@ -115,7 +112,7 @@ class Hasher {
    * @returns {this}
    */
   reset() {
-    this.inner.reset()
+    this.#inner.reset()
     return this
   }
 
@@ -123,14 +120,14 @@ class Hasher {
    * Dispose of resources
    */
   dispose() {
-    this.inner.free()
+    this.#inner.free()
   }
 
   /**
    * Free WASM resources (alias for dispose)
    */
   free() {
-    this.inner.free()
+    this.#inner.free()
   }
 }
 
@@ -200,10 +197,12 @@ export function root(payload) {
   if (payload.length <= CHUNK_SIZE) {
     return wasmRoot(payload)
   }
-  const hasher = create()
+  const hasher = new WasmHasher()
   try {
-    hasher.write(payload)
-    return hasher.inner.root()
+    for (let offset = 0; offset < payload.length; offset += CHUNK_SIZE) {
+      hasher.write(payload.subarray(offset, offset + CHUNK_SIZE))
+    }
+    return hasher.root()
   } finally {
     hasher.free()
   }

package/src/inline/commp.d.ts

@@ -0,0 +1,67 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export class CommPHasher {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a new hasher
+   */
+  constructor();
+  /**
+   * Get just the 32-byte CommP root hash
+   * 
+   * Returns the raw Merkle root without multihash encoding.
+   * Use `digest()` if you need the full multihash with metadata.
+   */
+  root(): Uint8Array;
+  /**
+   * Get bytes written count
+   */
+  count(): bigint;
+  /**
+   * Reset the hasher for reuse
+   */
+  reset(): void;
+  /**
+   * Write bytes into the hasher
+   *
+   * Throws a `RangeError` (without changing the hasher) if the total would
+   * exceed `MAX_PAYLOAD_SIZE`.
+   */
+  write(bytes: Uint8Array): void;
+  /**
+   * Get the full multihash-encoded digest
+   * 
+   * Returns: [code (varint 0x1011), size (varint), padding (varint), height (u8), root (32 bytes)]
+   * 
+   * - `code`: 0x1011 = "fr32-sha256-trunc254-padded-binary-tree" multihash identifier
+   * - `size`: total digest size (padding_len + 1 + 32)
+   * - `padding`: bytes of zero-padding added to reach next power-of-two piece size  
+   * - `height`: tree height (log2 of piece size / 32)
+   * - `root`: 32-byte Merkle root
+   */
+  digest(): Uint8Array;
+  /**
+   * Get the tree height
+   */
+  height(): number;
+}
+
+/**
+ * One-shot digest: returns full multihash-encoded CommP
+ * 
+ * Format: [code (varint 0x1011), size (varint), padding (varint), height (u8), root (32 bytes)]
+ * 
+ * Use this when you need the complete Filecoin piece commitment with metadata.
+ * The multihash code 0x1011 identifies this as "fr32-sha256-trunc254-padded-binary-tree".
+ */
+export function digest(data: Uint8Array): Uint8Array;
+
+/**
+ * One-shot root: returns just the 32-byte CommP root hash
+ * 
+ * Use this when you only need the raw hash without multihash encoding.
+ * This is the Merkle root of the FR32-padded, SHA256-hashed binary tree.
+ */
+export function root(data: Uint8Array): Uint8Array;