@ibgib/ts-gib 0.5.31 → 0.5.33

package/CHANGELOG.md

@@ -1,3 +1,23 @@
+# @ibgib/ts-gib changelog
+
+_note: as you implement features/fixes/etc., please document them here under the "Working Version" section. These will be moved to a concrete version number during the next publish._
+
+## Working Version
+
+## 0.5.33
+* performance: optimized `sha256v1` hashing function in `V1/sha256v1.mts`
+  * moved `toNormalizedForHashing` from internal closure to module scope and exported it, de-duplicating it in `helper.mts`.
+  * introduced pre-computed `BYTE_TO_HEX` static lookup table for zero-allocation hex conversion (`bufToHex` replaces slow `.map` chain).
+  * moved helper functions `hashToHex` and `hashToHex_Uint8Array` to module scope to avoid garbage collection and JIT re-compilation.
+  * collapsed dual-branch closure architecture (`if (salt) ... else ...`) into a unified, linear, non-branching execution flow.
+  * removed unused, deprecated `sha256v1_old` function.
+  * measured ~21.5% average speedup on KB-magnitude payloads and ~3% speedup on MB-magnitude payloads.
+* chore: centralized build orchestration
+  * migrated build, clean, and test logic to the root `@ibgib/build-gib` orchestrator.
+  * pruned legacy `package.json` scripts and archived them in `docs/ARCHIVE_SCRIPTS.md`.
+  * updated `prepare:publish` to use the centralized build engine.
+  * documented the new **Monorepo Build Policy** in the README.
+
 ## 0.5.28/29
 * added `squash` param to `firstGen`
   * for use when not using `dna` and you want the firstGen to output a single

package/README.md

@@ -21,6 +21,19 @@ Each quantum node has up to four fields, and each field in one word:
 This is extremely terse and naive of course. Here are slight more fleshed out
 descriptions of each field.
 
+## Build (Monorepo Policy)
+
+> [!IMPORTANT]
+> This project is part of a monorepo. Build and development tasks are centralized in the monorepo root via the `@ibgib/build-gib` orchestrator.
+
+### Development & Build
+Run these from the monorepo root:
+* `npm run build:ts-gib` - Performs a full clean and build.
+* `npm run test:ts-gib` - Runs the full respec-gib test suite for this library.
+
+### Legacy Scripts
+Individual package scripts have been streamlined to avoid redundancy. Previous scripts are archived in `docs/ARCHIVE_SCRIPTS.md` at the monorepo root.
+
 * `ib`
   * data and metadata
   * contains simple, core data you want to see _without loading the entire datum into memory_.

package/dist/V1/sha256v1.d.mts

@@ -1,16 +1,61 @@
 import { IbGib_V1 } from "./types.mjs";
 /**
- * Performs the gib hash like V1
+ * 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.
  *
- * I have it all in one function for smallest, most independent version possible.
+ * @param value The value to normalize.
+ * @returns The normalized value.
+ */
+export declare function toNormalizedForHashing(value: any): any;
+export declare const PROFILE_SHA256 = false;
+/**
+ * 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`.
  *
- * #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)
+ * 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 ibGib for which to calculate the gib
+ * @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 declare function sha256v1_old(ibGib: IbGib_V1, salt?: string): Promise<string>;
 export declare function sha256v1(ibGib: IbGib_V1, salt?: string): Promise<string>;
 /**
  * I have one large-ish sha256 function for gibbing purposes

package/dist/V1/sha256v1.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"sha256v1.d.mts","sourceRoot":"","sources":["../../src/V1/sha256v1.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAgC,MAAM,aAAa,CAAC;AAMrE;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,GAAE,MAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAyGhF;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,GAAE,MAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAoL5E;AAED;;;;;GAKG;AACH,wBAAsB,aAAa,CAC/B,OAAO,EAAE,MAAM,GAAG,SAAS,GAC5B,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAW7B"}
+{"version":3,"file":"sha256v1.d.mts","sourceRoot":"","sources":["../../src/V1/sha256v1.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAgC,MAAM,aAAa,CAAC;AA0BrE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,GAAG,GAAG,GAAG,CAyBtD;AAuBD,eAAO,MAAM,cAAc,QAAQ,CAAC;AAmEpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAsB,QAAQ,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,GAAE,MAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAalF;AAED;;;;;GAKG;AACH,wBAAsB,aAAa,CAC/B,OAAO,EAAE,MAAM,GAAG,SAAS,GAC5B,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAU7B"}

package/dist/V1/sha256v1.mjs

@@ -2,312 +2,198 @@ import { extractErrorMsg } from "@ibgib/helper-gib/dist/helpers/utils-helper.mjs
 let crypto = 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)
+ * 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.
+ */
+const BYTE_TO_HEX = new Array(256);
+for (let n = 0; n < 256; ++n) {
+    BYTE_TO_HEX[n] = n.toString(16).padStart(2, '0');
+}
+function bufToHex(buffer) {
+    const bytes = new Uint8Array(buffer);
+    let hex = '';
+    for (let i = 0; i < bytes.length; i++) {
+        hex += BYTE_TO_HEX[bytes[i]];
+    }
+    return hex;
+}
+/**
+ * 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 ibGib ibGib for which to calculate the gib
+ * @param value The value to normalize.
+ * @returns The normalized value.
  */
-export function sha256v1_old(ibGib, salt = "") {
-    // console.log('func_gib_sha256v1 executed');
-    if (!salt) {
-        salt = "";
+export function toNormalizedForHashing(value) {
+    // 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;
     }
-    let hashToHex = async (message) => {
-        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, msgUint8) => {
-        let tohashUint8Array;
-        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;
+    // Handle Arrays: recursively normalize elements, preserve order
+    if (Array.isArray(value)) {
+        return value.map(element => toNormalizedForHashing(element));
+    }
+    // Handle Objects (plain objects)
+    const normalizedObject = {};
+    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);
         }
-        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 propertyValue is undefined, it's omitted from normalizedObject.
+        // If propertyValue is null, it's included.
+    }
+    return normalizedObject;
+}
+async function hashToHex(message) {
+    if (!message) {
+        return "";
+    }
+    const msgUint8 = new TextEncoder().encode(message);
+    const buffer = await subtle.digest('SHA-256', msgUint8);
+    return bufToHex(buffer);
+}
+async function hashToHex_Uint8Array(salt, msgUint8) {
+    let tohashUint8Array;
     if (salt) {
-        hashFields = async (ib, data, 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.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 = 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 = "";
-            if (hasData) {
-                if (data instanceof Uint8Array) {
-                    dataHash = (await hashToHex_Uint8Array(salt, data)).toUpperCase();
-                }
-                else {
-                    dataHash = (await hashToHex(salt + 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(salt + ibHash + rel8nsHash + dataHash)).toUpperCase() :
-                (await hashToHex(salt + ibHash)).toUpperCase();
-            return allHash;
-        };
+        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 {
-        hashFields = async (ib, data, rel8ns) => {
-            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.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 = 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 = "";
-            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;
-        };
+        tohashUint8Array = msgUint8;
     }
-    return hashFields(ibGib.ib, ibGib?.data, ibGib?.rel8ns);
+    const hashAsBuffer = await subtle.digest('SHA-256', tohashUint8Array);
+    return bufToHex(hashAsBuffer);
 }
-export function sha256v1(ibGib, salt = "") {
-    // console.log('func_gib_sha256v1 executed');
-    if (!salt) {
-        salt = "";
-    }
-    let hashToHex = async (message) => {
-        if (!message) {
-            return "";
+export const PROFILE_SHA256 = false; // Toggle profiling
+let sha256v1CallCount = 0;
+let sha256v1TotalDuration = 0;
+/**
+ * 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, salt = "") {
+    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.length > 0;
         }
-        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, msgUint8) => {
-        let tohashUint8Array;
-        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 if (data instanceof Uint8Array) {
+            hasData = true;
         }
-        else {
-            tohashUint8Array = msgUint8;
+        else if (typeof data === 'object') {
+            hasData = Object.keys((data) || {}).length > 0;
         }
-        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) => {
-        // 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;
+        else {
+            hasData = true;
         }
-        // Handle Arrays: recursively normalize elements, preserve order
-        if (Array.isArray(value)) {
-            return value.map(element => toNormalizedForHashing(element));
+    }
+    const ibHash = (await hashToHex(s ? s + ib : ib)).toUpperCase();
+    let rel8nsHash = "";
+    if (hasRel8ns) {
+        const normalizedRel8ns = toNormalizedForHashing(rel8ns);
+        const rel8nsStr = JSON.stringify(normalizedRel8ns);
+        rel8nsHash = (await hashToHex(s ? s + rel8nsStr : rel8nsStr)).toUpperCase();
+    }
+    let dataHash = "";
+    if (hasData) {
+        if (data instanceof Uint8Array) {
+            dataHash = (await hashToHex_Uint8Array(s, data)).toUpperCase();
         }
-        // Handle Objects (plain objects)
-        const normalizedObject = {};
-        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.
+        else {
+            const normalizedData = toNormalizedForHashing(data);
+            const dataStr = JSON.stringify(normalizedData);
+            dataHash = (await hashToHex(s ? s + dataStr : dataStr)).toUpperCase();
         }
-        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 */
-        // }
-        // // we have an object. we will create a new object and populate it.
-        // const normalized = {};
-        // // sort keys alphabetically
-        // // NOTE: this does NOT mutate obj as Object.keys produces a new array
-        // const keys = Object.keys(obj).sort();
-        // 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;
-    };
-    let hashFields;
-    if (salt) {
-        hashFields = async (ib, data, 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.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 = 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)
-            // change this for binaries (Uint8Array data)
-            // const dataHash: string = hasData ? (await hashToHex(salt + JSON.stringify(data))).toUpperCase() : "";
-            let dataHash = "";
-            if (hasData) {
-                if (data instanceof Uint8Array) {
-                    dataHash = (await hashToHex_Uint8Array(salt, data)).toUpperCase();
-                }
-                else {
-                    dataHash = (await hashToHex(salt + 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(salt + ibHash + rel8nsHash + dataHash)).toUpperCase() :
-                (await hashToHex(salt + ibHash)).toUpperCase();
-            return allHash;
-        };
+    }
+    let allHash;
+    if (hasRel8ns || hasData) {
+        const combinedMsg = ibHash + rel8nsHash + dataHash;
+        allHash = (await hashToHex(s ? s + combinedMsg : combinedMsg)).toUpperCase();
     }
     else {
-        hashFields = async (ib, data, rel8ns) => {
-            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.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 = 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 = "";
-            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, salt = "") {
+    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);
 }
 /**
  * I have one large-ish sha256 function for gibbing purposes
@@ -322,13 +208,11 @@ export async function hashToHexCopy(message) {
     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;
     }
 }
-;
 //# sourceMappingURL=sha256v1.mjs.map