@ibgib/ts-gib 0.5.20 → 0.5.23

package/src/V1/transforms/{rel8.spec.mts → rel8.respec.mts}

@@ -6,12 +6,16 @@
  *   is required for browser until I get some kind of browser testing
  *   going.
  */
+import { clone, } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+import {
+    firstOfAll, ifWe, ifWeMight, iReckon, respecfully
+} from '@ibgib/helper-gib/dist/respec-gib/respec-gib.mjs';
+const maam = `[${import.meta.url}]`, sir = maam;
 
 import { IbGib_V1, IbGibRel8ns_V1, Rel8n } from '../types.mjs';
 import { TransformOpts_Rel8, IbGibAddr, IbGibRel8ns } from '../../types.mjs';
 import { getIbGibAddr, getIbAndGib } from '../../helper.mjs';
-import { pretty, clone, delay, } from '@ibgib/helper-gib';
-import { ROOT, ROOT_ADDR } from '../constants.mjs';
+import { ROOT_ADDR } from '../constants.mjs';
 import { fork } from './fork.mjs';
 // import { mut8 } from './mut8.mjs';
 import { rel8 } from './rel8.mjs';
@@ -84,7 +88,7 @@ await respecfully(sir, `can't rel8 primitives to others`, async () => {
             } catch (error) {
                 errored = true;
             }
-            iReckon(sir, errored).toBeTrue()
+            iReckon(sir, errored).isGonnaBeTrue()
         });
 
         await ifWe(sir, `should fail to remove rel8ns`, async () => {
@@ -95,7 +99,7 @@ await respecfully(sir, `can't rel8 primitives to others`, async () => {
             } catch (error) {
                 errored = true;
             }
-            iReckon(sir, errored).toBeTrue()
+            iReckon(sir, errored).isGonnaBeTrue()
         });
 
         await ifWe(sir, `should fail to add and remove rel8ns`, async () => {
@@ -109,7 +113,7 @@ await respecfully(sir, `can't rel8 primitives to others`, async () => {
             } catch (error) {
                 errored = true;
             }
-            iReckon(sir, errored).toBeTrue()
+            iReckon(sir, errored).isGonnaBeTrue()
         });
 
     }
@@ -138,12 +142,13 @@ await respecfully(sir, `when rel8ing a regular ibgib`, async () => {
                 iReckon(sir, rel8nsAddedIbGib.rel8ns).isGonnaBeTruthy();
                 const rel8nNames_AddedIbGib = Object.keys(rel8nsAddedIbGib.rel8ns!);
                 SIMPLE_REL8N_NAMES.forEach(simpleRel8nName => {
-                    iReckon(sir, rel8nNames_AddedIbGib).toContain(simpleRel8nName);
+                    iReckon(sir, rel8nNames_AddedIbGib).includes(simpleRel8nName);
                     const simpleRel8nAddrs = rel8nsAddedIbGib.rel8ns![simpleRel8nName]!;
-                    // expect(simpleRel8nAddrs).not.toHaveSize(0);
-                    iReckon(sir, simpleRel8nAddrs).not.toHaveSize(0);
-                    const expectedRel8nAddrs = rel8nsToAddByAddr[simpleRel8nName];
-                    iReckon(sir, expectedRel8nAddrs).not.toHaveSize(0);
+                    // iReckon(sir, simpleRel8nAddrs).not.toHaveSize(0);
+                    iReckon(sir, simpleRel8nAddrs.length === 0).isGonnaBeFalse();
+                    const expectedRel8nAddrs = rel8nsToAddByAddr[simpleRel8nName] ?? [];
+                    // iReckon(sir, expectedRel8nAddrs.length === 0).not.toHaveSize(0);
+                    iReckon(sir, expectedRel8nAddrs.length === 0).isGonnaBeFalse();
                     iReckon(sir, simpleRel8nAddrs).isGonnaBe(expectedRel8nAddrs!);
                 });
 
@@ -164,10 +169,10 @@ await respecfully(sir, `when rel8ing a regular ibgib`, async () => {
 
                 SIMPLE_REL8N_NAMES.forEach(simpleRel8nName => {
                     const rel8dAddrs = rel8nsRemovedIbGib.rel8ns![simpleRel8nName]!;
-                    // expect(rel8dAddrs).not.toContain(to.not.include.any.members([ROOT_ADDR, 'tag^gib']);
-                    [ROOT_ADDR, 'tag^gib'].forEach(x => { expect(rel8dAddrs).not.toContain(x); })
+                    // iReckon(sir, rel8dAddrs).not.includes(to.not.include.any.members([ROOT_ADDR, 'tag^gib']);
+                    [ROOT_ADDR, 'tag^gib'].forEach(x => { iReckon(sir, rel8dAddrs).not.includes(x); })
 
-                    // expect(rel8dAddrs).to.include.all.members(
+                    // iReckon(sir, rel8dAddrs).to.include.all.members(
                     //     PRIMITIVE_IBGIBS
                     //         .map(x => getIbGibAddr({ ibGib: x }))
                     //         .filter(addr => addr !== ROOT_ADDR && addr !== 'tag^gib')
@@ -175,7 +180,7 @@ await respecfully(sir, `when rel8ing a regular ibgib`, async () => {
                     PRIMITIVE_IBGIBS
                         .map(x => getIbGibAddr({ ibGib: x }))
                         .filter(addr => addr !== ROOT_ADDR && addr !== 'tag^gib')
-                        .forEach(x => expect(rel8dAddrs).toContain(x));
+                        .forEach(x => iReckon(sir, rel8dAddrs).includes(x));
                 });
 
                 //#endregion
@@ -213,11 +218,13 @@ await respecfully(sir, `when rel8ing a regular ibgib`, async () => {
                 const rel8DnaDataAdd: TransformOpts_Rel8<IbGib_V1> = clone(rel8DnaAdd.data!);
                 const rel8nNames_AddedIbGib = Object.keys(rel8nsAddedIbGib.rel8ns!);
                 SIMPLE_REL8N_NAMES.forEach(simpleRel8nName => {
-                    iReckon(sir, rel8nNames_AddedIbGib).toContain(simpleRel8nName);
+                    iReckon(sir, rel8nNames_AddedIbGib).includes(simpleRel8nName);
                     const simpleRel8nAddrs = rel8nsAddedIbGib.rel8ns![simpleRel8nName]!;
-                    iReckon(sir, simpleRel8nAddrs).not.toHaveSize(0);
-                    const expectedRel8nAddrs = rel8nsToAddByAddr[simpleRel8nName];
-                    iReckon(sir, expectedRel8nAddrs).not.toHaveSize(0);
+                    // iReckon(sir, simpleRel8nAddrs).not.toHaveSize(0);
+                    iReckon(sir, simpleRel8nAddrs.length === 0).isGonnaBeFalse();
+                    const expectedRel8nAddrs = rel8nsToAddByAddr[simpleRel8nName] ?? [];
+                    // iReckon(sir, expectedRel8nAddrs).not.toHaveSize(0);
+                    iReckon(sir, expectedRel8nAddrs.length === 0).isGonnaBeFalse();
                     iReckon(sir, simpleRel8nAddrs).isGonnaBe(expectedRel8nAddrs!);
                 });
 
@@ -230,11 +237,13 @@ await respecfully(sir, `when rel8ing a regular ibgib`, async () => {
                     await rel8(rel8DnaDataAdd);
                 const rel8nNames_AddedIbGib2 = Object.keys(rel8nsAddedIbGib2.rel8ns!);
                 SIMPLE_REL8N_NAMES.forEach(simpleRel8nName => {
-                    iReckon(sir, rel8nNames_AddedIbGib2).toContain(simpleRel8nName);
+                    iReckon(sir, rel8nNames_AddedIbGib2).includes(simpleRel8nName);
                     const simpleRel8nAddrs = rel8nsAddedIbGib2.rel8ns![simpleRel8nName]!;
-                    iReckon(sir, simpleRel8nAddrs).not.toHaveSize(0);
-                    const expectedRel8nAddrs = rel8nsToAddByAddr[simpleRel8nName];
-                    iReckon(sir, expectedRel8nAddrs).not.toHaveSize(0);
+                    // iReckon(sir, simpleRel8nAddrs).not.toHaveSize(0);
+                    iReckon(sir, simpleRel8nAddrs.length === 0).isGonnaBeFalse();
+                    const expectedRel8nAddrs = rel8nsToAddByAddr[simpleRel8nName] ?? [];
+                    // iReckon(sir, expectedRel8nAddrs).not.toHaveSize(0);
+                    iReckon(sir, expectedRel8nAddrs.length === 0).isGonnaBeFalse();
                     iReckon(sir, simpleRel8nAddrs).isGonnaBe(expectedRel8nAddrs!);
                 });
 
@@ -256,10 +265,10 @@ await respecfully(sir, `when rel8ing a regular ibgib`, async () => {
 
                 SIMPLE_REL8N_NAMES.forEach(simpleRel8nName => {
                     const rel8dAddrs = rel8nsRemovedIbGib.rel8ns![simpleRel8nName]!;
-                    // expect(rel8dAddrs).to.not.include.any.members([ROOT_ADDR, 'tag^gib']);
-                    [ROOT_ADDR, 'tag^gib'].every(x => { expect(rel8dAddrs).not.toContain(x); });
+                    // iReckon(sir, rel8dAddrs).to.not.include.any.members([ROOT_ADDR, 'tag^gib']);
+                    [ROOT_ADDR, 'tag^gib'].every(x => { iReckon(sir, rel8dAddrs).not.includes(x); });
 
-                    // expect(rel8dAddrs).to.include.all.members(
+                    // iReckon(sir, rel8dAddrs).to.include.all.members(
                     //     PRIMITIVE_IBGIBS
                     //         .map(x => getIbGibAddr({ ibGib: x }))
                     //         .filter(addr => addr !== ROOT_ADDR && addr !== 'tag^gib')
@@ -267,7 +276,7 @@ await respecfully(sir, `when rel8ing a regular ibgib`, async () => {
                     PRIMITIVE_IBGIBS
                         .map(x => getIbGibAddr({ ibGib: x }))
                         .filter(addr => addr !== ROOT_ADDR && addr !== 'tag^gib')
-                        .forEach(x => expect(rel8dAddrs).toContain(x));
+                        .forEach(x => iReckon(sir, rel8dAddrs).includes(x));
                 });
 
                 // rerun the same (un)rel8 call, but get the args from the dna of the
@@ -281,10 +290,10 @@ await respecfully(sir, `when rel8ing a regular ibgib`, async () => {
 
                 SIMPLE_REL8N_NAMES.forEach(simpleRel8nName => {
                     const rel8dAddrs = rel8nsRemovedIbGib2.rel8ns![simpleRel8nName]!;
-                    // expect(rel8dAddrs).to.not.include.any.members([ROOT_ADDR, 'tag^gib']);
-                    [ROOT_ADDR, 'tag^gib'].forEach(x => expect(rel8dAddrs).not.toContain(x))
+                    // iReckon(sir, rel8dAddrs).to.not.include.any.members([ROOT_ADDR, 'tag^gib']);
+                    [ROOT_ADDR, 'tag^gib'].forEach(x => iReckon(sir, rel8dAddrs).not.includes(x))
 
-                    // expect(rel8dAddrs).to.include.all.members(
+                    // iReckon(sir, rel8dAddrs).to.include.all.members(
                     //     PRIMITIVE_IBGIBS
                     //         .map(x => getIbGibAddr({ ibGib: x }))
                     //         .filter(addr => addr !== ROOT_ADDR && addr !== 'tag^gib')
@@ -292,7 +301,7 @@ await respecfully(sir, `when rel8ing a regular ibgib`, async () => {
                     PRIMITIVE_IBGIBS
                         .map(x => getIbGibAddr({ ibGib: x }))
                         .filter(addr => addr !== ROOT_ADDR && addr !== 'tag^gib')
-                        .forEach(x => expect(rel8dAddrs).toContain(x));
+                        .forEach(x => iReckon(sir, rel8dAddrs).includes(x));
                 });
 
                 //#endregion
@@ -346,29 +355,29 @@ await respecfully(sir, `when rel8ing a regular ibgib`, async () => {
                 const tjpAddr = getIbGibAddr({ ibGib: tjpIbGib });
                 const tjpAddrGib = getIbAndGib({ ibGibAddr: tjpAddr }).gib;
                 iReckon(sir, tjpIbGib?.data?.isTjp).asTo('src1.data.isTjp').isGonnaBeTruthy();
-                iReckon(sir, tjpIbGib?.rel8ns?.tjp).asTo('src1.rel8ns.tjp').toBeUndefined();
+                iReckon(sir, tjpIbGib?.rel8ns?.tjp).asTo('src1.rel8ns.tjp').isGonnaBeUndefined();
                 const { newIbGib: hasRel8dTjp } =
                     await rel8({ src: tjpIbGib, rel8nsToAddByAddr: testRel8ns });
                 const hasRel8dTjpAddr = getIbGibAddr({ ibGib: hasRel8dTjp });
                 const hasRel8dTjpAddrGib = getIbAndGib({ ibGibAddr: hasRel8dTjpAddr }).gib;
-                iReckon(sir, hasRel8dTjp?.data?.isTjp).asTo('src2.data.isTjp').toBeUndefined();
+                iReckon(sir, hasRel8dTjp?.data?.isTjp).asTo('src2.data.isTjp').isGonnaBeUndefined();
                 iReckon(sir, hasRel8dTjp?.rel8ns?.tjp).asTo('src2.rel8ns.tjp').isGonnaBeTruthy();
                 iReckon(sir, hasRel8dTjp!.rel8ns!.tjp!.length).asTo('src2.rel8ns.tjp.length').isGonnaBe(1);
-                iReckon(sir, hasRel8dTjp!.rel8ns!.tjp!).toContain(tjpAddr);
+                iReckon(sir, hasRel8dTjp!.rel8ns!.tjp!).includes(tjpAddr);
 
                 // the gib should not just be the hash, since it has a tjp timeline
-                iReckon(sir, hasRel8dTjpAddrGib).toContain(tjpAddrGib);
+                iReckon(sir, hasRel8dTjpAddrGib).includes(tjpAddrGib);
 
                 // shoe-horning in here some getGibInfo testing...eesh
                 const hasRel8dTjpGibInfo = getGibInfo({ ibGibAddr: hasRel8dTjpAddr }); // via addr
-                iReckon(sir, hasRel8dTjpGibInfo.isPrimitive).toBeUndefined();
-                iReckon(sir, hasRel8dTjpGibInfo.piecesCount).isGonnaBe(2, 'pieces count');
+                iReckon(sir, hasRel8dTjpGibInfo.isPrimitive).isGonnaBeUndefined();
+                iReckon(sir, hasRel8dTjpGibInfo.piecesCount).asTo('pieces count').isGonnaBe(2);
                 const hasRel8dTjpHash = await sha256v1(hasRel8dTjp, '');
-                iReckon(sir, hasRel8dTjpGibInfo.punctiliarHash).isGonnaBe(hasRel8dTjpHash, 'punctiliarHash');
+                iReckon(sir, hasRel8dTjpGibInfo.punctiliarHash).asTo('punctiliarHash').isGonnaBe(hasRel8dTjpHash);
                 iReckon(sir, hasRel8dTjpGibInfo.tjpGib).isGonnaBe(tjpAddrGib);
                 // the info should be the same if we get it straight from the gib
                 const hasRel8dTjpGibInfo_viaGib = getGibInfo({ gib: hasRel8dTjpAddrGib }); // via gib
-                iReckon(sir, hasRel8dTjpGibInfo_viaGib).isGonnaBe(hasRel8dTjpGibInfo, 'infos via addr and gib should be equal');
+                iReckon(sir, hasRel8dTjpGibInfo_viaGib).asTo('infos via addr and gib should be equal').isGonnaBe(hasRel8dTjpGibInfo);
 
                 // ok, yes my testing is out of control, but I'm going to shoehorn in here
                 // another rel8 and make sure that the punctiliar hash is correct and the gib only has two pieces.
@@ -379,8 +388,8 @@ await respecfully(sir, `when rel8ing a regular ibgib`, async () => {
                 const thirdGenGibInfo = getGibInfo({ ibGibAddr: thirdGenAddr });
                 const thirdGenHash = await sha256v1(thirdGenIbGib, '');
                 iReckon(sir, thirdGenGibInfo.punctiliarHash).isGonnaBe(thirdGenHash);
-                iReckon(sir, thirdGenGibInfo.tjpGib).isGonnaBe(tjpAddrGib, 'third gen match tjpAddrGib');
-                iReckon(sir, thirdGenGibInfo.piecesCount).isGonnaBe(2, 'third gen pieces');
+                iReckon(sir, thirdGenGibInfo.tjpGib).asTo('third gen match tjpAddrGib').isGonnaBe(tjpAddrGib);
+                iReckon(sir, thirdGenGibInfo.piecesCount).asTo('third gen pieces').isGonnaBe(2);
             });
         }
     });
@@ -393,7 +402,7 @@ await respecfully(sir, `when rel8ing a regular ibgib`, async () => {
 
                 iReckon(sir, src_0.data).isGonnaBeTruthy();
                 iReckon(sir, src_0.data!.n).isGonnaBe(0);
-                iReckon(sir, src_0!.data?.isTjp).asTo("isTjp").toBeUndefined();
+                iReckon(sir, src_0!.data?.isTjp).asTo("isTjp").isGonnaBeUndefined();
 
                 const rel8nsToAddByAddr = buildRel8nsToAddOrRemoveFromPrimitives(SIMPLE_REL8N_NAMES);
 
@@ -412,11 +421,13 @@ await respecfully(sir, `when rel8ing a regular ibgib`, async () => {
                 iReckon(sir, src_1.rel8ns).isGonnaBeTruthy();
                 const rel8nNames_AddedIbGib = Object.keys(src_1.rel8ns!);
                 SIMPLE_REL8N_NAMES.forEach(simpleRel8nName => {
-                    iReckon(sir, rel8nNames_AddedIbGib).toContain(simpleRel8nName);
+                    iReckon(sir, rel8nNames_AddedIbGib).includes(simpleRel8nName);
                     const simpleRel8nAddrs = src_1.rel8ns![simpleRel8nName]!;
-                    iReckon(sir, simpleRel8nAddrs).not.toHaveSize(0);
-                    const expectedRel8nAddrs = rel8nsToAddByAddr[simpleRel8nName];
-                    iReckon(sir, expectedRel8nAddrs).not.toHaveSize(0);
+                    // iReckon(sir, simpleRel8nAddrs).not.toHaveSize(0);
+                    iReckon(sir, simpleRel8nAddrs.length === 0).isGonnaBeFalse();
+                    const expectedRel8nAddrs = rel8nsToAddByAddr[simpleRel8nName] ?? [];
+                    // iReckon(sir, expectedRel8nAddrs).not.toHaveSize(0);
+                    iReckon(sir, expectedRel8nAddrs.length === 0).isGonnaBeFalse();
                     iReckon(sir, simpleRel8nAddrs).isGonnaBe(expectedRel8nAddrs!);
                 });
 
@@ -425,7 +436,7 @@ await respecfully(sir, `when rel8ing a regular ibgib`, async () => {
                 iReckon(sir, src_1.data!.n).isGonnaBeTruthy();
                 iReckon(sir, src_1.data!.n).isGonnaBeTruthy();
                 iReckon(sir, src_1.data!.n).isGonnaBe(1);
-                iReckon(sir, src_1!.data?.isTjp).asTo("isTjp").toBeUndefined();
+                iReckon(sir, src_1!.data?.isTjp).asTo("isTjp").isGonnaBeUndefined();
             }
         });
         await ifWe(sir, `should start new n counter, implicit nCounter falsy`, async () => {
@@ -435,7 +446,7 @@ await respecfully(sir, `when rel8ing a regular ibgib`, async () => {
 
                 iReckon(sir, src_0.data).isGonnaBeTruthy();
                 iReckon(sir, src_0.data).isGonnaBeTruthy();
-                iReckon(sir, src_0.data!.n).toBeUndefined();
+                iReckon(sir, src_0.data!.n).isGonnaBeUndefined();
 
                 const rel8nsToAddByAddr = buildRel8nsToAddOrRemoveFromPrimitives(SIMPLE_REL8N_NAMES);
 
@@ -454,11 +465,13 @@ await respecfully(sir, `when rel8ing a regular ibgib`, async () => {
                 iReckon(sir, src_1.rel8ns).isGonnaBeTruthy();
                 const rel8nNames_AddedIbGib = Object.keys(src_1.rel8ns!);
                 SIMPLE_REL8N_NAMES.forEach(simpleRel8nName => {
-                    iReckon(sir, rel8nNames_AddedIbGib).toContain(simpleRel8nName);
+                    iReckon(sir, rel8nNames_AddedIbGib).includes(simpleRel8nName);
                     const simpleRel8nAddrs = src_1.rel8ns![simpleRel8nName]!;
-                    iReckon(sir, simpleRel8nAddrs).not.toHaveSize(0);
-                    const expectedRel8nAddrs = rel8nsToAddByAddr[simpleRel8nName];
-                    iReckon(sir, expectedRel8nAddrs).not.toHaveSize(0);
+                    // iReckon(sir, simpleRel8nAddrs).not.toHaveSize(0);
+                    iReckon(sir, simpleRel8nAddrs.length === 0).isGonnaBeFalse();
+                    const expectedRel8nAddrs = rel8nsToAddByAddr[simpleRel8nName] ?? [];
+                    // iReckon(sir, expectedRel8nAddrs).not.toHaveSize(0);
+                    iReckon(sir, expectedRel8nAddrs.length === 0).isGonnaBeFalse();
                     iReckon(sir, simpleRel8nAddrs).isGonnaBe(expectedRel8nAddrs!);
                 });
 
@@ -473,8 +486,8 @@ await respecfully(sir, `when rel8ing a regular ibgib`, async () => {
 
                 iReckon(sir, src_0.data).isGonnaBeTruthy();
                 iReckon(sir, src_0.data).isGonnaBeTruthy();
-                iReckon(sir, src_0.data!.n).toBeUndefined();
-                iReckon(sir, src_0!.data!.isTjp).asTo("isTjp").toBeUndefined();
+                iReckon(sir, src_0.data!.n).isGonnaBeUndefined();
+                iReckon(sir, src_0!.data!.isTjp).asTo("isTjp").isGonnaBeUndefined();
 
                 const rel8nsToAddByAddr = buildRel8nsToAddOrRemoveFromPrimitives(SIMPLE_REL8N_NAMES);
 
@@ -493,24 +506,26 @@ await respecfully(sir, `when rel8ing a regular ibgib`, async () => {
                 iReckon(sir, src_1.rel8ns).isGonnaBeTruthy();
                 const rel8nNames_AddedIbGib = Object.keys(src_1.rel8ns!);
                 SIMPLE_REL8N_NAMES.forEach(simpleRel8nName => {
-                    iReckon(sir, rel8nNames_AddedIbGib).toContain(simpleRel8nName);
+                    iReckon(sir, rel8nNames_AddedIbGib).includes(simpleRel8nName);
                     const simpleRel8nAddrs = src_1.rel8ns![simpleRel8nName]!;
-                    iReckon(sir, simpleRel8nAddrs).not.toHaveSize(0);
-                    const expectedRel8nAddrs = rel8nsToAddByAddr[simpleRel8nName];
-                    iReckon(sir, expectedRel8nAddrs).not.toHaveSize(0);
+                    // iReckon(sir, simpleRel8nAddrs).not.toHaveSize(0);
+                    iReckon(sir, simpleRel8nAddrs.length === 0).isGonnaBeFalse();
+                    const expectedRel8nAddrs = rel8nsToAddByAddr[simpleRel8nName] ?? [];
+                    // iReckon(sir, expectedRel8nAddrs).not.toHaveSize(0);
+                    iReckon(sir, expectedRel8nAddrs.length === 0).isGonnaBeFalse();
                     iReckon(sir, simpleRel8nAddrs).isGonnaBe(expectedRel8nAddrs!);
                 });
 
                 iReckon(sir, src_1.data).isGonnaBeTruthy();
                 iReckon(sir, src_1.data!.n).isGonnaBe(0);
-                iReckon(sir, src_1!.data!.isTjp).asTo("isTjp").toBeUndefined();
+                iReckon(sir, src_1!.data!.isTjp).asTo("isTjp").isGonnaBeUndefined();
             }
         });
         //     for (const primitive of PRIMITIVE_IBGIBS) {
         //         let { newIbGib: src_0 } =
         //             await fork({src: primitive, noTimestamp: true, nCounter: false});
 
-        //         expect(src_0.data).toBeUndefined();
+        //         iReckon(sir, src_0.data).isGonnaBeUndefined();
 
         //         let { newIbGib: src_1 } =
         //             await mut8({
@@ -518,8 +533,8 @@ await respecfully(sir, `when rel8ing a regular ibgib`, async () => {
         //                 dataToAddOrPatch: DATA_SIMPLE_XY,
         //                 nCounter: true
         //             });
-        //         expect(src_1.data).isGonnaBeTruthy();
-        //         expect(src_1.data!.n).isGonnaBe(0);
+        //         iReckon(sir, src_1.data).isGonnaBeTruthy();
+        //         iReckon(sir, src_1.data!.n).isGonnaBe(0);
         //     }
         // });
 

package/src/V1/transforms/{transform-helper.spec.mts → transform-helper.respec.mts}

@@ -2,15 +2,15 @@
  * Test transform-helper.
  */
 
+import {
+    firstOfEach, firstOfAll, ifWe,
+    lastOfEach, lastOfAll,
+    ifWeMight, iReckon, respecfully,
+    respecfullyDear
+} from '@ibgib/helper-gib/dist/respec-gib/respec-gib.mjs';
+const maam = `[${import.meta.url}]`, sir = maam;
 
-// import { IbGib_V1, IbGibRel8ns_V1, Rel8n } from '../types.mjs';
-// import { TransformOpts_Rel8, IbGibAddr, IbGibRel8ns } from '../../types.mjs';
-// import { getIbGibAddr, getIbAndGib } from '../../helper.mjs';
-// import { pretty, clone, delay, } from '@ibgib/helper-gib';
-// import { ROOT, ROOT_ADDR } from '../constants.mjs';
 import { fork } from './fork.mjs';
-// import { mut8 } from './mut8.mjs';
-// import { rel8 } from './rel8.mjs';
 import { Factory_V1 as factory } from '../factory.mjs';
 import { isDna } from './transform-helper.mjs';
 
@@ -32,14 +32,14 @@ await respecfully(sir, `isDna`, async () => {
             const resFork = await fork({ src, dna: true });
             resFork.dnas?.every(x => {
                 const resIsDna = isDna({ ibGib: x });
-                iReckon(sir, resIsDna).toBeTrue()
+                iReckon(sir, resIsDna).isGonnaBeTrue()
             });
         });
 
         await ifWe(sir, `should return false for non-dna ibgibs`, async () => {
             const resFork = await fork({ src, dna: true });
             const resIsDna = isDna({ ibGib: resFork.newIbGib });
-            iReckon(sir, resIsDna).toBeFalse();
+            iReckon(sir, resIsDna).isGonnaBeFalse();
         });
 
     }

package/src/V1/v1-helper.mts

@@ -1,8 +1,9 @@
-import { getIbGibAddr, getIbAndGib } from '../helper.mjs';
-import { pretty, clone, delay, } from '@ibgib/helper-gib';
-import * as cTsGib from './constants.mjs';
+import { clone, } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+
+import { getIbGibAddr, } from '../helper.mjs';
 import { getGibInfo } from './transforms/transform-helper.mjs';
 import { IbGibRel8ns_V1, IbGib_V1 } from "./types.mjs";
+import { GIB, GIB_DELIMITER } from './constants.mjs';
 
 /**
  * Helper function that checks the given `ibGib` to see if it
@@ -49,11 +50,11 @@ export function hasTjp({ ibGib }: { ibGib: IbGib_V1 }): boolean {
         console.warn(`${lc} ibGib.gib falsy. (W: 6400d780822b44d992846f1196509be3)`);
         return false;
     }
-    if (ibGib.gib.includes(cTsGib.GIB_DELIMITER)) {
+    if (ibGib.gib.includes(GIB_DELIMITER)) {
         return true;
     }
 
-    if (ibGib.gib === cTsGib.GIB) {
+    if (ibGib.gib === GIB) {
         // primitive
         return false;
     }

package/src/helper.mts

@@ -74,3 +74,51 @@ 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;
+}

package/src/helper.respec.mts

@@ -1,7 +1,7 @@
 import { ifWe, ifWeMight, iReckon, respecfully } from '@ibgib/helper-gib/dist/respec-gib/respec-gib.mjs';
 const maam = `[${import.meta.url}]`, sir = maam;
 
-import { getIbAndGib, getIbGibAddr } from './helper.mjs';
+import { getIbAndGib, getIbGibAddr, toNormalizedForHashing } from './helper.mjs';
 import { Ib, IbGib } from './types.mjs';
 import { ROOT, ROOT_ADDR } from './V1/constants.mjs';
 
@@ -60,3 +60,83 @@ await respecfully(sir, `getIbAndGib`, async () => {
     });
 
 });
+
+await respecfully(sir, `normalize object testing for deterministic hashing`, async () => {
+    await ifWe(sir, `null, '', {}, undefined, [], etc...`, async () => {
+        [
+            null,
+            '',
+            {},
+            undefined,
+            [],
+            'some string',
+        ].forEach(obj1 => {
+            const normalized1 = toNormalizedForHashing(obj1);
+            iReckon(sir, JSON.stringify(obj1))
+                .asTo("Original object should not be modified.")
+                .isGonnaBe(JSON.stringify(normalized1));
+        });
+    });
+
+    await ifWe(sir, `flat (sort and undefined)`, async () => {
+        // test cases with varying key orders and undefined values
+        const obj1 = { a: 1, b: 2, c: undefined };
+        const obj2 = { c: undefined, b: 2, a: 1 };
+        const obj3 = { a: 1, b: 2 };
+
+        // check original object state before normalization
+        const originalObj1String = JSON.stringify(obj1);
+
+        // normalize the objects
+        const normalized1 = toNormalizedForHashing(obj1);
+        const normalized2 = toNormalizedForHashing(obj2);
+        const normalized3 = toNormalizedForHashing(obj3);
+
+        // check original object state after normalization to ensure it's unchanged
+        iReckon(sir, JSON.stringify(obj1)).asTo("Original object should not be modified.").isGonnaBe(originalObj1String);
+
+        // convert to JSON strings for easy comparison of normalized objects
+        const json1 = JSON.stringify(normalized1);
+        const json2 = JSON.stringify(normalized2);
+        const json3 = JSON.stringify(normalized3);
+
+        // assertions for normalization
+        iReckon(sir, json1).asTo("Objects with different key orders should normalize to the same string.").isGonnaBe(json2);
+        iReckon(sir, json1).asTo("Object with undefined should normalize to the same string as without that key.").isGonnaBe(json3);
+
+        // parse normalized strings back into objects and re-normalize
+        const parsedNormalized1 = toNormalizedForHashing(JSON.parse(json1));
+        const parsedNormalized2 = toNormalizedForHashing(JSON.parse(json2));
+        const parsedNormalized3 = toNormalizedForHashing(JSON.parse(json3));
+
+        // sanity check
+        iReckon(sir, parsedNormalized1).asTo("parsedNormalized1 truthy").isGonnaBeTruthy();
+        iReckon(sir, parsedNormalized2).asTo("parsedNormalized2 truthy").isGonnaBeTruthy();
+        iReckon(sir, parsedNormalized3).asTo("parsedNormalized3 truthy").isGonnaBeTruthy();
+
+        // check if re-normalized objects produce the same string as the original normalized objects
+        iReckon(sir, obj1.a).asTo("parsed object `a` property is the same as original object").isGonnaBe(parsedNormalized1["a"]);
+        iReckon(sir, JSON.stringify(parsedNormalized1) === json1).asTo("Re-normalized object should produce the same string as the original normalized object.").isGonnaBeTrue();
+        iReckon(sir, JSON.stringify(parsedNormalized2) === json2).asTo("Re-normalized object should produce the same string as the original normalized object.").isGonnaBeTrue();
+        iReckon(sir, JSON.stringify(parsedNormalized3) === json3).asTo("Re-normalized object should produce the same string as the original normalized object.").isGonnaBeTrue();
+    });
+
+    await ifWe(sir, `nested (sort and undefined)`, async () => {
+        // test with nested objects
+        const nested1 = { a: { z: 1, y: 2 }, b: 3, c: undefined };
+        const nested2 = { b: 3, a: { y: 2, z: 1 } };
+
+        // normalize nested objects
+        const normalizedNested1 = toNormalizedForHashing(nested1);
+        const normalizedNested2 = toNormalizedForHashing(nested2);
+
+        // compare the original and normalized objects' properties
+        iReckon(sir, normalizedNested1.a?.z).asTo("nested object `a.z` property is the same as original object").isGonnaBe(nested1.a.z);
+        iReckon(sir, normalizedNested1.a?.y).asTo("nested object `a.y` property is the same as original object").isGonnaBe(nested1.a.y);
+        iReckon(sir, normalizedNested1.b).asTo("nested object `b` property is the same as original object").isGonnaBe(nested1.b);
+        iReckon(sir, normalizedNested1.c).asTo("nested object `c` property is the same as original object").isGonnaBe(nested1.c);
+
+        // check if nested objects are normalized correctly
+        iReckon(sir, JSON.stringify(normalizedNested1)).asTo("Nested objects should normalize to the same string.").isGonnaBe(JSON.stringify(normalizedNested2));
+    });
+});

package/src/respec-gib.node.mts

@@ -2,7 +2,7 @@ import { readdir, open } from 'node:fs/promises';
 import { statSync } from 'node:fs';
 import * as pathUtils from 'path';
 
-import { pretty } from '@ibgib/helper-gib';
+import { pretty } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
 import { getGlobalRespecGib } from '@ibgib/helper-gib/dist/respec-gib/respec-gib.mjs';
 
 // #region settings