@ibgib/ts-gib 0.5.31 → 0.5.33

package/src/V1/sha256v1.mts

@@ -6,303 +6,208 @@ let crypto: any = globalThis.crypto;
 let { subtle } = crypto;
 
 /**
- * Performs the gib hash like V1
- *
- * I have it all in one function for smallest, most independent version possible.
- *
- * #thanks https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/digest
- * #thanks https://stackoverflow.com/questions/49129643/how-do-i-merge-an-array-of-uint8arrays
- * #thanks https://stackoverflow.com/a/49129872/3897838 (answer to above)
- *
- * @param ibGib ibGib for which to calculate the gib
+ * Pre-computed lookup table mapping byte values (0-255) to their 2-digit padded
+ * hex string representations. Used by {@link bufToHex} to convert ArrayBuffers
+ * to hex strings with zero string/array allocations per byte, significantly
+ * reducing garbage collection thrashing in high-frequency hashing paths.
  */
-export function sha256v1_old(ibGib: IbGib_V1, salt: string = ""): Promise<string> {
-    // console.log('func_gib_sha256v1 executed');
-    if (!salt) { salt = ""; }
-    let hashToHex = async (message: string | undefined) => {
-        if (!message) { return ""; }
-        const msgUint8 = new TextEncoder().encode(message);
-        const buffer = await subtle.digest('SHA-256', msgUint8);
-        const asArray = Array.from(new Uint8Array(buffer));
-        // return hashAsHex
-        return asArray.map(b => b.toString(16).padStart(2, '0')).join('');
-    };
-    let hashToHex_Uint8Array = async (salt: string, msgUint8: Uint8Array) => {
-        let tohashUint8Array: Uint8Array;
-        if (salt) {
-            const msgUint8_salt = new TextEncoder().encode(salt);
-            tohashUint8Array = new Uint8Array(msgUint8_salt.length + msgUint8.length);
-            tohashUint8Array.set(msgUint8_salt);
-            tohashUint8Array.set(msgUint8, msgUint8_salt.length);
-        } else {
-            tohashUint8Array = msgUint8;
-        }
-        const hashAsBuffer = await subtle.digest('SHA-256', tohashUint8Array);
-        const hashAsArray = Array.from(new Uint8Array(hashAsBuffer));
-        // return hashAsHex
-        return hashAsArray.map(b => b.toString(16).padStart(2, '0')).join('');
-    };
-    let hashFields;
-    if (salt) {
-        hashFields = async (ib: Ib, data: IbGibData_V1 | undefined, rel8ns: IbGibRel8ns_V1 | undefined) => {
-            const hasRel8ns =
-                Object.keys(rel8ns || {}).length > 0 &&
-                Object.keys(rel8ns || {}).some(k => rel8ns![k] && rel8ns![k]!.length > 0);
-            let hasData = !!data;
-            if (hasData) {
-                if (typeof data === 'string') {
-                    hasData = (data as string).length > 0;
-                } else if (data instanceof Uint8Array) {
-                    hasData = true;
-                } else if (typeof data === 'object') {
-                    hasData = Object.keys((data) || {}).length > 0;
-                } else {
-                    hasData = true;
-                }
-            }
-            const ibHash = (await hashToHex(salt + ib)).toUpperCase();
-            // empty, null, undefined all treated the same at this level.
-            const rel8nsHash: string = hasRel8ns ? (await hashToHex(salt + JSON.stringify(rel8ns))).toUpperCase() : "";
-            // empty, null, undefined all treated the same at this level (though not farther down in data)
-
-            // change this for binaries (Uint8Array data)
-            // const dataHash: string = hasData ? (await hashToHex(salt + JSON.stringify(data))).toUpperCase() : "";
-            let dataHash: string = "";
-            if (hasData) {
-                if (data instanceof Uint8Array) {
-                    dataHash = (await hashToHex_Uint8Array(salt, data)).toUpperCase();
-                } else {
-                    dataHash = (await hashToHex(salt + JSON.stringify(data))).toUpperCase();
-                }
-            }
+const BYTE_TO_HEX: string[] = new Array(256);
+for (let n = 0; n < 256; ++n) {
+    BYTE_TO_HEX[n] = n.toString(16).padStart(2, '0');
+}
 
-            // if the ibgib has no rel8ns or data, the hash should be just of the ib itself.
-            const allHash = hasRel8ns || hasData ?
-                (await hashToHex(salt + ibHash + rel8nsHash + dataHash)).toUpperCase() :
-                (await hashToHex(salt + ibHash)).toUpperCase();
-            return allHash;
-        };
-    } else {
-        hashFields = async (ib: Ib, data: IbGibData_V1 | undefined, rel8ns: IbGibRel8ns_V1 | undefined) => {
-            const hasRel8ns =
-                Object.keys(rel8ns || {}).length > 0 &&
-                Object.keys(rel8ns || {}).some(k => rel8ns![k] && rel8ns![k]!.length > 0);
-            // const hasData = Object.keys((data) || {}).length > 0;
-            let hasData = !!data;
-            if (hasData) {
-                if (typeof data === 'string') {
-                    hasData = (data as string).length > 0;
-                } else if (data instanceof Uint8Array) {
-                    hasData = true;
-                } else if (typeof data === 'object') {
-                    hasData = Object.keys((data) || {}).length > 0;
-                } else {
-                    hasData = true;
-                }
-            }
-            const ibHash = (await hashToHex(ib)).toUpperCase();
-            // empty, null, undefined all treated the same at this level.
-            const rel8nsHash: string = hasRel8ns ? (await hashToHex(JSON.stringify(rel8ns))).toUpperCase() : "";
-            // empty, null, undefined all treated the same at this level (though not farther down in data)
-            // const dataHash: string = hasData ? (await hashToHex(JSON.stringify(data))).toUpperCase() : "";
-            let dataHash: string = "";
-            if (hasData) {
-                if (data instanceof Uint8Array) {
-                    dataHash = (await hashToHex_Uint8Array('', data)).toUpperCase();
-                } else {
-                    dataHash = (await hashToHex(JSON.stringify(data))).toUpperCase();
-                }
-            }
-            // if the ibgib has no rel8ns or data, the hash should be just of the ib itself.
-            const allHash = hasRel8ns || hasData ?
-                (await hashToHex(ibHash + rel8nsHash + dataHash)).toUpperCase() :
-                (await hashToHex(ibHash)).toUpperCase();
-            return allHash;
-        }
+function bufToHex(buffer: ArrayBuffer): string {
+    const bytes = new Uint8Array(buffer);
+    let hex = '';
+    for (let i = 0; i < bytes.length; i++) {
+        hex += BYTE_TO_HEX[bytes[i]];
     }
-    return hashFields(ibGib.ib, ibGib?.data, ibGib?.rel8ns);
+    return hex;
 }
 
-export function sha256v1(ibGib: IbGib_V1, salt: string = ""): Promise<string> {
-    // console.log('func_gib_sha256v1 executed');
-    if (!salt) { salt = ""; }
-    let hashToHex = async (message: string | undefined) => {
-        if (!message) { return ""; }
-        const msgUint8 = new TextEncoder().encode(message);
-        const buffer = await subtle.digest('SHA-256', msgUint8);
-        const asArray = Array.from(new Uint8Array(buffer));
-        // return hashAsHex
-        return asArray.map(b => b.toString(16).padStart(2, '0')).join('');
-    };
-    let hashToHex_Uint8Array = async (salt: string, msgUint8: Uint8Array) => {
-        let tohashUint8Array: Uint8Array;
-        if (salt) {
-            const msgUint8_salt = new TextEncoder().encode(salt);
-            tohashUint8Array = new Uint8Array(msgUint8_salt.length + msgUint8.length);
-            tohashUint8Array.set(msgUint8_salt);
-            tohashUint8Array.set(msgUint8, msgUint8_salt.length);
-        } else {
-            tohashUint8Array = msgUint8;
-        }
-        const hashAsBuffer = await subtle.digest('SHA-256', tohashUint8Array);
-        const hashAsArray = Array.from(new Uint8Array(hashAsBuffer));
-        // return hashAsHex
-        return hashAsArray.map(b => b.toString(16).padStart(2, '0')).join('');
-    };
-
-    /**
-     * THIS IS DUPLICATED CODE IN THE RESPEC FILE. ANY CHANGES HERE MUST
-     * MANUALLY BE CHANGED IN THE RESPEC FILE!!!
-     *
-     * Normalizes an object/value for consistent hashing.
-     * - Recursively processes objects and arrays.
-     * - For objects:
-     *   - Sorts keys alphabetically.
-     *   - Removes properties whose values are `undefined`.
-     *   - Keeps properties whose values are `null`.
-     * - For arrays:
-     *   - Preserves element order.
-     *   - Recursively normalizes each element.
-     * - Primitives (strings, numbers, booleans) and `null` are returned as is.
-     *
-     * THIS IS DUPLICATED CODE IN THE RESPEC FILE. ANY CHANGES HERE MUST
-     * MANUALLY BE CHANGED IN THE RESPEC FILE!!!
-     *
-     * @param value The value to normalize.
-     * @returns The normalized value.
-     */
-    const toNormalizedForHashing = (value: any) => {
-        // Handle null, primitives (string, number, boolean) directly.
-        // `undefined` at the top level will be handled by the caller or become part of an object/array.
-        if (value === null || typeof value !== 'object') {
-            return value;
-        }
+/**
+ * Normalizes an object/value for consistent hashing.
+ * - Recursively processes objects and arrays.
+ * - For objects:
+ *   - Sorts keys alphabetically.
+ *   - Removes properties whose values are `undefined`.
+ *   - Keeps properties whose values are `null`.
+ * - For arrays:
+ *   - Preserves element order.
+ *   - Recursively normalizes each element.
+ * - Primitives (strings, numbers, booleans) and `null` are returned as is.
+ *
+ * @param value The value to normalize.
+ * @returns The normalized value.
+ */
+export function toNormalizedForHashing(value: any): any {
+    // Handle null, primitives (string, number, boolean) directly.
+    // `undefined` at the level will be handled by the caller or become part of an object/array.
+    if (value === null || typeof value !== 'object') {
+        return value;
+    }
 
-        // Handle Arrays: recursively normalize elements, preserve order
-        if (Array.isArray(value)) {
-            return value.map(element => toNormalizedForHashing(element));
-        }
+    // Handle Arrays: recursively normalize elements, preserve order
+    if (Array.isArray(value)) {
+        return value.map(element => toNormalizedForHashing(element));
+    }
 
-        // Handle Objects (plain objects)
-        const normalizedObject: { [key: string]: any } = {};
-        const sortedKeys = Object.keys(value).sort();
+    // Handle Objects (plain objects)
+    const normalizedObject: { [key: string]: any } = {};
+    const sortedKeys = Object.keys(value).sort();
 
-        for (const key of sortedKeys) {
-            const propertyValue = value[key];
-            if (propertyValue !== undefined) { // CRITICAL: Only omit if value is undefined
-                normalizedObject[key] = toNormalizedForHashing(propertyValue);
-            }
-            // If propertyValue is undefined, it's omitted from normalizedObject.
-            // If propertyValue is null, it's included.
+    for (const key of sortedKeys) {
+        const propertyValue = value[key];
+        if (propertyValue !== undefined) { // CRITICAL: Only omit if value is undefined
+            normalizedObject[key] = toNormalizedForHashing(propertyValue);
         }
-        return normalizedObject;
+        // If propertyValue is undefined, it's omitted from normalizedObject.
+        // If propertyValue is null, it's included.
+    }
+    return normalizedObject;
+}
 
-        // if (!obj) {
-        //     return obj; /* <<<< returns early */
-        // } else if (typeof obj === 'string' || Array.isArray(obj)) {
-        //     return obj.concat(); /* <<<< returns early */
-        // } else if (typeof obj !== 'object') {
-        //     // Return non-objects as is, we don't know how to concat/copy it...hmm...
-        //     return obj;  /* <<<< returns early */
-        // }
+async function hashToHex(message: string | undefined): Promise<string> {
+    if (!message) { return ""; }
+    const msgUint8 = new TextEncoder().encode(message);
+    const buffer = await subtle.digest('SHA-256', msgUint8);
+    return bufToHex(buffer);
+}
 
-        // // we have an object. we will create a new object and populate it.
-        // const normalized = {};
+async function hashToHex_Uint8Array(salt: string, msgUint8: Uint8Array): Promise<string> {
+    let tohashUint8Array: Uint8Array;
+    if (salt) {
+        const msgUint8_salt = new TextEncoder().encode(salt);
+        tohashUint8Array = new Uint8Array(msgUint8_salt.length + msgUint8.length);
+        tohashUint8Array.set(msgUint8_salt);
+        tohashUint8Array.set(msgUint8, msgUint8_salt.length);
+    } else {
+        tohashUint8Array = msgUint8;
+    }
+    const hashAsBuffer = await subtle.digest('SHA-256', tohashUint8Array);
+    return bufToHex(hashAsBuffer);
+}
 
-        // // sort keys alphabetically
-        // // NOTE: this does NOT mutate obj as Object.keys produces a new array
-        // const keys = Object.keys(obj).sort();
+export const PROFILE_SHA256 = false; // Toggle profiling
+let sha256v1CallCount = 0;
+let sha256v1TotalDuration = 0;
 
-        // for (const key of keys) {
-        //     const value = obj[key];
-        //     if (value !== undefined) {
-        //         // Recursively normalize if the value is an object
-        //         normalized[key] = (typeof value === 'object' && value !== null) ? toNormalizedForHashing(value) : value;
-        //     }
-        // }
-        // return normalized;
+/**
+ * The internal, optimized implementation of the V1 punctiliar hashing algorithm.
+ * Contains the linear, non-branching execution path that computes the hashes
+ * for the individual components (ib, data, rel8ns) and combines them.
+ *
+ * @param ibGib The ibGib object to hash.
+ * @param salt An optional cryptographic salt.
+ * @returns A promise that resolves to the calculated punctiliar gib string.
+ */
+async function sha256v1_Internal(ibGib: IbGib_V1, salt: string = ""): Promise<string> {
+    const s = salt || "";
+    const ib = ibGib.ib;
+    const data = ibGib.data;
+    const rel8ns = ibGib.rel8ns;
+
+    const hasRel8ns =
+        Object.keys(rel8ns || {}).length > 0 &&
+        Object.keys(rel8ns || {}).some(k => rel8ns![k] && rel8ns![k]!.length > 0);
+
+    let hasData = !!data;
+    if (hasData) {
+        if (typeof data === 'string') {
+            hasData = (data as string).length > 0;
+        } else if (data instanceof Uint8Array) {
+            hasData = true;
+        } else if (typeof data === 'object') {
+            hasData = Object.keys((data) || {}).length > 0;
+        } else {
+            hasData = true;
+        }
     }
 
+    const ibHash = (await hashToHex(s ? s + ib : ib)).toUpperCase();
 
-    let hashFields;
-    if (salt) {
-        hashFields = async (ib: Ib, data: IbGibData_V1 | undefined, rel8ns: IbGibRel8ns_V1 | undefined) => {
-            const hasRel8ns =
-                Object.keys(rel8ns || {}).length > 0 &&
-                Object.keys(rel8ns || {}).some(k => rel8ns![k] && rel8ns![k]!.length > 0);
-            let hasData = !!data;
-            if (hasData) {
-                if (typeof data === 'string') {
-                    hasData = (data as string).length > 0;
-                } else if (data instanceof Uint8Array) {
-                    hasData = true;
-                } else if (typeof data === 'object') {
-                    hasData = Object.keys((data) || {}).length > 0;
-                } else {
-                    hasData = true;
-                }
-            }
-            const ibHash = (await hashToHex(salt + ib)).toUpperCase();
-            // empty, null, undefined all treated the same at this level.
-            const rel8nsHash: string = hasRel8ns ? (await hashToHex(salt + JSON.stringify(toNormalizedForHashing(rel8ns)))).toUpperCase() : "";
-            // empty, null, undefined all treated the same at this level (though not farther down in data)
+    let rel8nsHash = "";
+    if (hasRel8ns) {
+        const normalizedRel8ns = toNormalizedForHashing(rel8ns);
+        const rel8nsStr = JSON.stringify(normalizedRel8ns);
+        rel8nsHash = (await hashToHex(s ? s + rel8nsStr : rel8nsStr)).toUpperCase();
+    }
 
-            // change this for binaries (Uint8Array data)
-            // const dataHash: string = hasData ? (await hashToHex(salt + JSON.stringify(data))).toUpperCase() : "";
-            let dataHash: string = "";
-            if (hasData) {
-                if (data instanceof Uint8Array) {
-                    dataHash = (await hashToHex_Uint8Array(salt, data)).toUpperCase();
-                } else {
-                    dataHash = (await hashToHex(salt + JSON.stringify(toNormalizedForHashing(data)))).toUpperCase();
-                }
-            }
+    let dataHash = "";
+    if (hasData) {
+        if (data instanceof Uint8Array) {
+            dataHash = (await hashToHex_Uint8Array(s, data)).toUpperCase();
+        } else {
+            const normalizedData = toNormalizedForHashing(data);
+            const dataStr = JSON.stringify(normalizedData);
+            dataHash = (await hashToHex(s ? s + dataStr : dataStr)).toUpperCase();
+        }
+    }
 
-            // if the ibgib has no rel8ns or data, the hash should be just of the ib itself.
-            const allHash = hasRel8ns || hasData ?
-                (await hashToHex(salt + ibHash + rel8nsHash + dataHash)).toUpperCase() :
-                (await hashToHex(salt + ibHash)).toUpperCase();
-            return allHash;
-        };
+    let allHash: string;
+    if (hasRel8ns || hasData) {
+        const combinedMsg = ibHash + rel8nsHash + dataHash;
+        allHash = (await hashToHex(s ? s + combinedMsg : combinedMsg)).toUpperCase();
     } else {
-        hashFields = async (ib: Ib, data: IbGibData_V1 | undefined, rel8ns: IbGibRel8ns_V1 | undefined) => {
-            const hasRel8ns =
-                Object.keys(rel8ns || {}).length > 0 &&
-                Object.keys(rel8ns || {}).some(k => rel8ns![k] && rel8ns![k]!.length > 0);
-            // const hasData = Object.keys((data) || {}).length > 0;
-            let hasData = !!data;
-            if (hasData) {
-                if (typeof data === 'string') {
-                    hasData = (data as string).length > 0;
-                } else if (data instanceof Uint8Array) {
-                    hasData = true;
-                } else if (typeof data === 'object') {
-                    hasData = Object.keys((data) || {}).length > 0;
-                } else {
-                    hasData = true;
-                }
-            }
-            const ibHash = (await hashToHex(ib)).toUpperCase();
-            // empty, null, undefined all treated the same at this level.
-            const rel8nsHash: string = hasRel8ns ? (await hashToHex(JSON.stringify(toNormalizedForHashing(rel8ns)))).toUpperCase() : "";
-            // empty, null, undefined all treated the same at this level (though not farther down in data)
-            // const dataHash: string = hasData ? (await hashToHex(JSON.stringify(data))).toUpperCase() : "";
-            let dataHash: string = "";
-            if (hasData) {
-                if (data instanceof Uint8Array) {
-                    dataHash = (await hashToHex_Uint8Array('', data)).toUpperCase();
-                } else {
-                    dataHash = (await hashToHex(JSON.stringify(toNormalizedForHashing(data)))).toUpperCase();
-                }
-            }
-            // if the ibgib has no rel8ns or data, the hash should be just of the ib itself.
-            const allHash = hasRel8ns || hasData ?
-                (await hashToHex(ibHash + rel8nsHash + dataHash)).toUpperCase() :
-                (await hashToHex(ibHash)).toUpperCase();
-            return allHash;
+        allHash = (await hashToHex(s ? s + ibHash : ibHash)).toUpperCase();
+    }
+
+    return allHash;
+}
+
+/**
+ * Computes the composite hash algorithm that generates a single **punctiliar**
+ * `gib` for an incoming ibGib object.
+ *
+ * IMPORTANT: This function does not calculate the tjpGib (timeline junction point)
+ * or the complete, fully resolved timeline `gib`. It is the primitive hashing mechanism
+ * that only calculates the punctiliar (point-in-time) hash of this specific ibgib's structure.
+ * Consumers should generally use `getGib` which handles complete timeline gib calculations
+ * and delegates to this function under the hood.
+ *
+ * ### How the V1 Punctiliar Hashing Algorithm Works:
+ * 1. **Normalization**: The incoming `data` and `rel8ns` objects are recursively normalized 
+ *    using {@link toNormalizedForHashing} to ensure deterministic, reproducible results:
+ *    - Plain objects have their keys sorted alphabetically, and properties with `undefined` 
+ *      values are omitted (while `null` values are kept).
+ *    - Arrays preserve their element order but recursively normalize their elements.
+ * 2. **Salting**: An optional string `salt` is prepended to the encoded strings during hashing 
+ *    (or combined as raw bytes for binary data).
+ * 3. **Intermediate Hashes**: The components are hashed individually using SHA-256 and converted 
+ *    to uppercase hex strings:
+ *    - `ibHash`: Computed from the string `[salt] + ib`.
+ *    - `rel8nsHash`: If relations exist, computed from the string `[salt] + JSON.stringify(normalizedRel8ns)`. Otherwise, resolves to `""`.
+ *    - `dataHash`: If data exists, computed as follows:
+ *      - If the data is a `Uint8Array` (binary), hashed directly by combining the salted bytes and data bytes.
+ *      - Otherwise, computed from the string `[salt] + JSON.stringify(normalizedData)`.
+ *      - If data does not exist, resolves to `""`.
+ * 4. **Composite (Final) Hash**:
+ *    - If relations or data exist: Computed from the string `[salt] + ibHash + rel8nsHash + dataHash`.
+ *    - Otherwise, computed from the string `[salt] + ibHash`.
+ *
+ * Implementation details:
+ * - Eliminates internal closures by using module-scoped helpers.
+ * - Utilizes a pre-computed byte-to-hex lookup table to prevent GC thrashing.
+ * - Collapses branching logic into a unified, linear, non-branching execution flow.
+ * - Optional high-resolution telemetry profiling is toggleable via `PROFILE_SHA256`.
+ *
+ * @param ibGib The ibGib object whose punctiliar hash is to be computed.
+ * @param salt An optional cryptographic salt string.
+ * @returns A promise resolving to the canonical punctiliar `gib` hash string in uppercase.
+ */
+export async function sha256v1(ibGib: IbGib_V1, salt: string = ""): Promise<string> {
+    if (PROFILE_SHA256) {
+        const start = globalThis.performance ? globalThis.performance.now() : Date.now();
+        const res = await sha256v1_Internal(ibGib, salt);
+        const duration = (globalThis.performance ? globalThis.performance.now() : Date.now()) - start;
+        sha256v1CallCount++;
+        sha256v1TotalDuration += duration;
+        if (sha256v1CallCount % 1000 === 0) {
+            console.log(`[sha256v1 Profile] Total Runs: ${sha256v1CallCount} | Average Duration: ${(sha256v1TotalDuration / sha256v1CallCount).toFixed(4)} ms`);
         }
+        return res;
     }
-    return hashFields(ibGib.ib, ibGib?.data, ibGib?.rel8ns); // conditional nav ibGib?.data and ibGib?.rel8ns
+    return sha256v1_Internal(ibGib, salt);
 }
 
 /**
@@ -318,10 +223,9 @@ export async function hashToHexCopy(
     try {
         const msgUint8 = new TextEncoder().encode(message);
         const buffer = await subtle.digest('SHA-256', msgUint8);
-        const asArray = Array.from(new Uint8Array(buffer));
-        return asArray.map(b => b.toString(16).padStart(2, '0')).join('');
+        return bufToHex(buffer);
     } catch (e) {
         console.error(extractErrorMsg(e.message));
         return undefined;
     }
-};
+}

package/src/V1/sha256v1.respec.mts

@@ -17,12 +17,11 @@ import {
 const maam = `[${import.meta.url}]`, sir = maam;
 
 import { IbGib_V1, IbGibRel8ns_V1 } from './types.mjs';
-import { sha256v1, hashToHexCopy } from './sha256v1.mjs';
+import { sha256v1, hashToHexCopy, toNormalizedForHashing } from './sha256v1.mjs';
 import { IbGibWithDataAndRel8ns, IbGibRel8ns } from '../types.mjs';
 import { getGib, getGibInfo } from './transforms/transform-helper.mjs';
 
 import { Factory_V1 as factory } from './factory.mjs';
-import { toNormalizedForHashing } from '../helper.mjs';
 
 // #region Test Data
 
@@ -587,4 +586,48 @@ await respecfully(sir, `Python Edge Case Tests for sha256v1`, async () => {
         iReckon(sir, calculatedGib_ts).asTo(`calculatedGib_ts for s10b (from sha256v1 call)`).isGonnaBe(expected_gib_s10b);
     });
 
+    await ifWe(sir, `performance profiling test`, async () => {
+        // MB-magnitude data test (100 iterations)
+        const mbString = "A".repeat(1024 * 1024); // 1 MB
+        const ibGibMb: IbGib_V1 = {
+            ib: 'performance_test_mb',
+            data: {
+                large_str: mbString
+            }
+        };
+        const startMb = globalThis.performance ? globalThis.performance.now() : Date.now();
+        const iterationsMb = 100;
+        let lastGibMb = "";
+        for (let i = 0; i < iterationsMb; i++) {
+            lastGibMb = await sha256v1(ibGibMb);
+        }
+        const durationMb = (globalThis.performance ? globalThis.performance.now() : Date.now()) - startMb;
+        console.log(`\n[PROFILE] MB Payload (${iterationsMb} iterations): Total Time = ${durationMb.toFixed(2)}ms | Avg = ${(durationMb / iterationsMb).toFixed(4)}ms (last gib: ${lastGibMb})`);
+
+        // KB-magnitude data test (1000 iterations)
+        const kbData: any = {};
+        for (let i = 0; i < 100; i++) {
+            kbData[`key_${i}`] = "some string value that is relatively long to accumulate size. ".repeat(5); // ~30KB total
+        }
+        const ibGibKb: IbGib_V1 = {
+            ib: 'performance_test_kb',
+            data: kbData,
+            rel8ns: {
+                some_rel: ['addr1', 'addr2', 'addr3', 'addr4']
+            }
+        };
+
+        const startKb = globalThis.performance ? globalThis.performance.now() : Date.now();
+        const iterationsKb = 1000;
+        let lastGibKb = "";
+        for (let i = 0; i < iterationsKb; i++) {
+            lastGibKb = await sha256v1(ibGibKb);
+        }
+        const durationKb = (globalThis.performance ? globalThis.performance.now() : Date.now()) - startKb;
+        console.log(`[PROFILE] KB Payload (${iterationsKb} iterations): Total Time = ${durationKb.toFixed(2)}ms | Avg = ${(durationKb / iterationsKb).toFixed(4)}ms (last gib: ${lastGibKb})\n`);
+
+        iReckon(sir, !!lastGibKb).isGonnaBe(true);
+        iReckon(sir, !!lastGibMb).isGonnaBe(true);
+    });
+
 });

package/src/helper.mts

@@ -1,4 +1,5 @@
 import { Ib, Gib, IbGib, IbGibAddr, IbAndGib } from './types.mjs';
+import { toNormalizedForHashing } from './V1/sha256v1.mjs';
 
 
 /**
@@ -76,49 +77,4 @@ export function getIbAndGib({
 }
 
 
-/**
- * Normalizes an object/value for consistent hashing.
- * - Recursively processes objects and arrays.
- * - For objects:
- *   - Sorts keys alphabetically.
- *   - Removes properties whose values are `undefined`.
- *   - Keeps properties whose values are `null`.
- * - For arrays:
- *   - Preserves element order.
- *   - Recursively normalizes each element.
- * - Primitives (strings, numbers, booleans) and `null` are returned as is.
- *
- * @param value The value to normalize.
- * @returns The normalized value.
- *
- * This has been adjusted due to conversation with Gemini and working on python
- * port.  The main thing here is that we normalize array members, but not the
- * array itself. This way the array's order is preserved, but any object members
- * are themselves normalized.
- */
-export function toNormalizedForHashing(value: any): any {
-    // Handle null, primitives (string, number, boolean) directly.
-    // `undefined` at the top level will be handled by the caller or become part of an object/array.
-    if (value === null || typeof value !== 'object') {
-        return value;
-    }
-
-    // Handle Arrays: recursively normalize elements, preserve order
-    if (Array.isArray(value)) {
-        return value.map(element => toNormalizedForHashing(element));
-    }
-
-    // Handle Objects (plain objects)
-    const normalizedObject: { [key: string]: any } = {};
-    const sortedKeys = Object.keys(value).sort();
-
-    for (const key of sortedKeys) {
-        const propertyValue = value[key];
-        if (propertyValue !== undefined) { // CRITICAL: Only omit if value is undefined
-            normalizedObject[key] = toNormalizedForHashing(propertyValue);
-        }
-        // If propertyValue is undefined, it's omitted from normalizedObject.
-        // If propertyValue is null, it's included.
-    }
-    return normalizedObject;
-}
+export { toNormalizedForHashing };

package/.vscode/launch.json

@@ -1,24 +0,0 @@
-{
-    // Use IntelliSense to learn about possible attributes.
-    // Hover to view descriptions of existing attributes.
-    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
-    "version": "0.2.0",
-    "configurations": [
-        {
-            "type": "node",
-            "request": "launch",
-            "name": "npm debug",
-            "runtimeExecutable": "npm",
-            "runtimeArgs": [
-                "run",
-                "debug",
-            ],
-            "port": 9229,
-            "sourceMaps": true,
-            "skipFiles": [
-                "<node_internals>/**"
-            ]
-        },
-
-    ]
-}