@iscc/wasm 0.0.3 → 0.1.0

package/README.md

@@ -4,9 +4,6 @@
 [![npm](https://img.shields.io/npm/v/@iscc/wasm.svg)](https://www.npmjs.com/package/@iscc/wasm)
 [![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 
-> **Experimental:** This library is in early development (v0.0.x). APIs may change without notice.
-> Not recommended for production use yet.
-
 Browser-compatible WebAssembly bindings for
 [ISO 24138:2024](https://www.iso.org/standard/77899.html) -- International Standard Content Code
 (ISCC). Built with Rust and [wasm-bindgen](https://rustwasm.github.io/wasm-bindgen/) for use in
@@ -54,6 +51,7 @@ Both browser and Node.js targets are supported.
 | `gen_data_code_v0`     | Generate a Data-Code from raw bytes          |
 | `gen_instance_code_v0` | Generate an Instance-Code from raw bytes     |
 | `gen_iscc_code_v0`     | Generate a composite ISCC-CODE               |
+| `gen_sum_code_v0`      | Generate an ISCC-SUM from raw bytes          |
 
 All code generators return ISCC strings directly.
 

package/iscc_wasm.d.ts

@@ -94,6 +94,11 @@ export class IsccDecodeResult {
  */
 export function META_TRIM_DESCRIPTION(): number;
 
+/**
+ * Maximum byte length for the meta field payload after decoding.
+ */
+export function META_TRIM_META(): number;
+
 /**
  * Maximum byte length for the name field after trimming.
  */
@@ -104,6 +109,35 @@ export function META_TRIM_NAME(): number;
  */
 export function TEXT_NGRAM_SIZE(): number;
 
+/**
+ * Result of [`gen_sum_code_v0`], containing the composite ISCC-CODE, data hash, and file size.
+ */
+export class WasmSumCodeResult {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Hex-encoded BLAKE3 multihash (`"1e20..."`) of the data.
+     */
+    datahash: string;
+    /**
+     * Byte length of the input data (as `f64` for JS `number` compatibility).
+     */
+    filesize: number;
+    /**
+     * Composite ISCC-CODE string (e.g., `"ISCC:KAC..."`).
+     */
+    iscc: string;
+    /**
+     * Data-Code and Instance-Code ISCC strings (when `add_units` is true).
+     */
+    get units(): string[] | undefined;
+    /**
+     * Data-Code and Instance-Code ISCC strings (when `add_units` is true).
+     */
+    set units(value: string[] | null | undefined);
+}
+
 /**
  * Split data into content-defined chunks using gear rolling hash.
  *
@@ -201,6 +235,18 @@ export function gen_meta_code_v0(name: string, description?: string | null, meta
  */
 export function gen_mixed_code_v0(codes: any, bits?: number | null): string;
 
+/**
+ * Generate a composite ISCC-CODE from raw byte data in a single pass.
+ *
+ * Feeds both `DataHasher` (CDC/MinHash) and `InstanceHasher` (BLAKE3) from
+ * the same byte slice, then composes the final ISCC-CODE via
+ * `gen_iscc_code_v0`. WASM-compatible alternative to the file-based core API.
+ *
+ * When `add_units` is `true`, the result includes the individual Data-Code
+ * and Instance-Code ISCC strings.
+ */
+export function gen_sum_code_v0(data: Uint8Array, bits?: number | null, wide?: boolean | null, add_units?: boolean | null): WasmSumCodeResult;
+
 /**
  * Generate a Text-Code from plain text content.
  *
@@ -297,6 +343,7 @@ export interface InitOutput {
     readonly memory: WebAssembly.Memory;
     readonly IO_READ_SIZE: () => number;
     readonly META_TRIM_DESCRIPTION: () => number;
+    readonly META_TRIM_META: () => number;
     readonly META_TRIM_NAME: () => number;
     readonly TEXT_NGRAM_SIZE: () => number;
     readonly __wbg_datahasher_free: (a: number, b: number) => void;
@@ -305,6 +352,10 @@ export interface InitOutput {
     readonly __wbg_get_isccdecoderesult_maintype: (a: number) => number;
     readonly __wbg_get_isccdecoderesult_subtype: (a: number) => number;
     readonly __wbg_get_isccdecoderesult_version: (a: number) => number;
+    readonly __wbg_get_wasmsumcoderesult_datahash: (a: number, b: number) => void;
+    readonly __wbg_get_wasmsumcoderesult_filesize: (a: number) => number;
+    readonly __wbg_get_wasmsumcoderesult_iscc: (a: number, b: number) => void;
+    readonly __wbg_get_wasmsumcoderesult_units: (a: number, b: number) => void;
     readonly __wbg_instancehasher_free: (a: number, b: number) => void;
     readonly __wbg_isccdecoderesult_free: (a: number, b: number) => void;
     readonly __wbg_set_isccdecoderesult_digest: (a: number, b: number, c: number) => void;
@@ -312,6 +363,11 @@ export interface InitOutput {
     readonly __wbg_set_isccdecoderesult_maintype: (a: number, b: number) => void;
     readonly __wbg_set_isccdecoderesult_subtype: (a: number, b: number) => void;
     readonly __wbg_set_isccdecoderesult_version: (a: number, b: number) => void;
+    readonly __wbg_set_wasmsumcoderesult_datahash: (a: number, b: number, c: number) => void;
+    readonly __wbg_set_wasmsumcoderesult_filesize: (a: number, b: number) => void;
+    readonly __wbg_set_wasmsumcoderesult_iscc: (a: number, b: number, c: number) => void;
+    readonly __wbg_set_wasmsumcoderesult_units: (a: number, b: number, c: number) => void;
+    readonly __wbg_wasmsumcoderesult_free: (a: number, b: number) => void;
     readonly alg_cdc_chunks: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly alg_minhash_256: (a: number, b: number, c: number) => void;
     readonly alg_simhash: (a: number, b: number) => void;
@@ -327,6 +383,7 @@ export interface InitOutput {
     readonly gen_iscc_code_v0: (a: number, b: number, c: number) => void;
     readonly gen_meta_code_v0: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
     readonly gen_mixed_code_v0: (a: number, b: number, c: number) => void;
+    readonly gen_sum_code_v0: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly gen_text_code_v0: (a: number, b: number, c: number, d: number) => void;
     readonly gen_video_code_v0: (a: number, b: number, c: number) => void;
     readonly instancehasher_finalize: (a: number, b: number, c: number) => void;

package/iscc_wasm.js

@@ -290,6 +290,15 @@ export function META_TRIM_DESCRIPTION() {
     return ret >>> 0;
 }
 
+/**
+ * Maximum byte length for the meta field payload after decoding.
+ * @returns {number}
+ */
+export function META_TRIM_META() {
+    const ret = wasm.META_TRIM_META();
+    return ret >>> 0;
+}
+
 /**
  * Maximum byte length for the name field after trimming.
  * @returns {number}
@@ -308,6 +317,132 @@ export function TEXT_NGRAM_SIZE() {
     return ret >>> 0;
 }
 
+/**
+ * Result of [`gen_sum_code_v0`], containing the composite ISCC-CODE, data hash, and file size.
+ */
+export class WasmSumCodeResult {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmSumCodeResult.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmSumCodeResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmSumCodeResultFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmsumcoderesult_free(ptr, 0);
+    }
+    /**
+     * Hex-encoded BLAKE3 multihash (`"1e20..."`) of the data.
+     * @returns {string}
+     */
+    get datahash() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.__wbg_get_wasmsumcoderesult_datahash(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Byte length of the input data (as `f64` for JS `number` compatibility).
+     * @returns {number}
+     */
+    get filesize() {
+        const ret = wasm.__wbg_get_wasmsumcoderesult_filesize(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Composite ISCC-CODE string (e.g., `"ISCC:KAC..."`).
+     * @returns {string}
+     */
+    get iscc() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.__wbg_get_wasmsumcoderesult_iscc(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Data-Code and Instance-Code ISCC strings (when `add_units` is true).
+     * @returns {string[] | undefined}
+     */
+    get units() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.__wbg_get_wasmsumcoderesult_units(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            let v1;
+            if (r0 !== 0) {
+                v1 = getArrayJsValueFromWasm0(r0, r1).slice();
+                wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            }
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Hex-encoded BLAKE3 multihash (`"1e20..."`) of the data.
+     * @param {string} arg0
+     */
+    set datahash(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_wasmsumcoderesult_datahash(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Byte length of the input data (as `f64` for JS `number` compatibility).
+     * @param {number} arg0
+     */
+    set filesize(arg0) {
+        wasm.__wbg_set_wasmsumcoderesult_filesize(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Composite ISCC-CODE string (e.g., `"ISCC:KAC..."`).
+     * @param {string} arg0
+     */
+    set iscc(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_wasmsumcoderesult_iscc(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Data-Code and Instance-Code ISCC strings (when `add_units` is true).
+     * @param {string[] | null} [arg0]
+     */
+    set units(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passArrayJsValueToWasm0(arg0, wasm.__wbindgen_export);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_wasmsumcoderesult_units(this.__wbg_ptr, ptr0, len0);
+    }
+}
+if (Symbol.dispose) WasmSumCodeResult.prototype[Symbol.dispose] = WasmSumCodeResult.prototype.free;
+
 /**
  * Split data into content-defined chunks using gear rolling hash.
  *
@@ -708,6 +843,39 @@ export function gen_mixed_code_v0(codes, bits) {
     }
 }
 
+/**
+ * Generate a composite ISCC-CODE from raw byte data in a single pass.
+ *
+ * Feeds both `DataHasher` (CDC/MinHash) and `InstanceHasher` (BLAKE3) from
+ * the same byte slice, then composes the final ISCC-CODE via
+ * `gen_iscc_code_v0`. WASM-compatible alternative to the file-based core API.
+ *
+ * When `add_units` is `true`, the result includes the individual Data-Code
+ * and Instance-Code ISCC strings.
+ * @param {Uint8Array} data
+ * @param {number | null} [bits]
+ * @param {boolean | null} [wide]
+ * @param {boolean | null} [add_units]
+ * @returns {WasmSumCodeResult}
+ */
+export function gen_sum_code_v0(data, bits, wide, add_units) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.gen_sum_code_v0(retptr, ptr0, len0, isLikeNone(bits) ? 0x100000001 : (bits) >>> 0, isLikeNone(wide) ? 0xFFFFFF : wide ? 1 : 0, isLikeNone(add_units) ? 0xFFFFFF : add_units ? 1 : 0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return WasmSumCodeResult.__wrap(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
 /**
  * Generate a Text-Code from plain text content.
  *
@@ -1208,6 +1376,9 @@ const InstanceHasherFinalization = (typeof FinalizationRegistry === 'undefined')
 const IsccDecodeResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_isccdecoderesult_free(ptr >>> 0, 1));
+const WasmSumCodeResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmsumcoderesult_free(ptr >>> 0, 1));
 
 function addHeapObject(obj) {
     if (heap_next === heap.length) heap.push(heap.length + 1);
@@ -1366,6 +1537,16 @@ function passArray8ToWasm0(arg, malloc) {
     return ptr;
 }
 
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4, 4) >>> 0;
+    const mem = getDataViewMemory0();
+    for (let i = 0; i < array.length; i++) {
+        mem.setUint32(ptr + 4 * i, addHeapObject(array[i]), true);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
+
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@iscc/wasm",
   "type": "module",
-  "version": "0.0.3",
+  "version": "0.1.0",
   "files": [
     "iscc_wasm_bg.wasm",
     "iscc_wasm.js",