@ibgib/ts-gib 0.5.20 → 0.5.23

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

@@ -16,12 +16,20 @@
  *   is required for browser until I get some kind of browser testing
  *   going.
  */
+import { clone, delay, } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+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 { fork } from './fork.mjs';
 import { TransformOpts_Fork, IbGibAddr, Ib, TransformResult } from '../../types.mjs';
-import { getIbGibAddr } from '../../helper.mjs';
-import { pretty, clone, delay, } from '@ibgib/helper-gib';
-import { ROOT, ROOT_ADDR } from '../constants.mjs';
+import { getIbGibAddr, toNormalizedForHashing } from '../../helper.mjs';
+import { ROOT, } from '../constants.mjs';
 import { mut8 } from './mut8.mjs';
 import { getGib } from './transform-helper.mjs';
 
@@ -36,14 +44,14 @@ await respecfully(sir, `when forking the root`, async () => {
 
     await ifWe(sir, `should have no rel8ns (because forked from the root)`, async () => {
         const { newIbGib } = await fork({ src });
-        iReckon(sir, newIbGib.rel8ns).toBeUndefined();
+        iReckon(sir, newIbGib.rel8ns).isGonnaBeUndefined();
     });
 
     await respecfully(sir, `should respect param`, async () => {
         await ifWe(sir, `noTimestamp`, async () => {
             const { newIbGib } = await fork({ src, noTimestamp: true });
             if (newIbGib?.data) {
-                iReckon(sir, newIbGib.data!.timestamp).toBeUndefined();
+                iReckon(sir, newIbGib.data!.timestamp).isGonnaBeUndefined();
             } else {
                 // data being falsy is passing so no expect statement needed
             }
@@ -86,13 +94,13 @@ await respecfully(sir, `when forking the root`, async () => {
                 // counting on environment (node) to be consistent with invalid dates in the future
                 const invalidDate = new Date("asdf");
                 iReckon(sir, invalidDate.toString()).isGonnaBe("Invalid Date");
-                iReckon(sir, newIbGib!.data?.isTjp).asTo("isTjp").toBeTrue();
+                iReckon(sir, newIbGib!.data?.isTjp).asTo("isTjp").isGonnaBeTrue();
             });
             await ifWe(sir, `uuid`, async () => {
                 const { newIbGib } = await fork({ src, tjp: { uuid: true } });
                 iReckon(sir, newIbGib?.data).isGonnaBeTruthy();
                 iReckon(sir, newIbGib!.data?.uuid).isGonnaBeTruthy();
-                iReckon(sir, newIbGib!.data?.isTjp).asTo("isTjp").toBeTrue()
+                iReckon(sir, newIbGib!.data?.isTjp).asTo("isTjp").isGonnaBeTrue()
             });
             await ifWe(sir, `timestamp && uuid`, async () => {
                 const { newIbGib } = await fork({ src, tjp: { timestamp: true, uuid: true } });
@@ -104,7 +112,7 @@ await respecfully(sir, `when forking the root`, async () => {
                 iReckon(sir, testDate).isGonnaBeTruthy();
                 iReckon(sir, testDate.toString()).not.isGonnaBe("Invalid Date");
                 iReckon(sir, newIbGib!.data?.uuid).isGonnaBeTruthy();
-                iReckon(sir, newIbGib!.data?.isTjp).asTo("isTjp").toBeTrue()
+                iReckon(sir, newIbGib!.data?.isTjp).asTo("isTjp").isGonnaBeTrue()
             });
         });
 
@@ -117,12 +125,12 @@ await respecfully(sir, `when forking the root`, async () => {
 
         await ifWe(sir, `cloneRel8ns (setting should be ignored since forking root)`, async () => {
             const { newIbGib } = await fork({ src, cloneRel8ns: true, noTimestamp: true });
-            iReckon(sir, newIbGib?.rel8ns).toBeUndefined();
+            iReckon(sir, newIbGib?.rel8ns).isGonnaBeUndefined();
         });
 
         await ifWe(sir, `cloneData (setting should be ignored since forking root)`, async () => {
             const { newIbGib } = await fork({ src, cloneData: true, noTimestamp: true });
-            iReckon(sir, newIbGib?.data).toBeUndefined();
+            iReckon(sir, newIbGib?.data).isGonnaBeUndefined();
         });
     });
 
@@ -150,9 +158,9 @@ await respecfully(sir, `when forking the root`, async () => {
             const forkDnaData = (forkDna.data as TransformOpts_Fork<IbGib_V1>)!;
 
             iReckon(sir, forkDna.data).asTo(`should have well-formed common transform opts`).isGonnaBeTruthy();
-            iReckon(sir, forkDnaData.dna).asTo(`should have well-formed common transform opts`).toBeTrue()
-            iReckon(sir, forkDnaData.srcAddr).asTo(`should have well-formed common transform opts`).toBeUndefined();
-            iReckon(sir, forkDnaData.src).asTo(`should have well-formed common transform opts`).toBeUndefined();
+            iReckon(sir, forkDnaData.dna).asTo(`should have well-formed common transform opts`).isGonnaBeTrue()
+            iReckon(sir, forkDnaData.srcAddr).asTo(`should have well-formed common transform opts`).isGonnaBeUndefined();
+            iReckon(sir, forkDnaData.src).asTo(`should have well-formed common transform opts`).isGonnaBeUndefined();
 
             iReckon(sir, forkDnaData.type).asTo(`should have well-formed data specific to fork transform`).isGonnaBe("fork");
             iReckon(sir, forkDnaData.destIb).asTo(`should have well-formed data specific to fork transform`).isGonnaBe(destIb);
@@ -196,7 +204,8 @@ await respecfully(sir, `when forking a regular ibgib`, async () => {
     let src: IbGib_V1;
     let srcAddr: IbGibAddr;
 
-    beforeEach(async () => {
+
+    firstOfEach(sir, async () => {
         // This will be the src we're working off of.
         const beforeResult = await fork({ src: ROOT, uuid: true });
         src = beforeResult.newIbGib;
@@ -243,10 +252,11 @@ await respecfully(sir, `when forking a regular ibgib`, async () => {
         // need to reconsider inability to rename/remove timestamp data
         // seems silly since bad actors can always do this and security is
         // really through other means.
-        const testData = { x: 1, y: 2, deeper: { zzz: 333 }, uuid: 'tbd', timestamp: 'tbd' };
+        const testData = { x: 1, y: 2, deeper: { zzz: 333 }, uuid: 'tbd', timestamp: 'tbd', timestampMs: -1 };
         const { newIbGib: grandparent } = await fork({ src, cloneData: true, noTimestamp: true });
         testData.uuid = grandparent.data!.uuid!;
         testData.timestamp = grandparent.data!.timestamp!;
+        testData.timestampMs = grandparent.data!.timestampMs!;
         const { newIbGib: parent } =
             await mut8({
                 src: grandparent,
@@ -261,13 +271,15 @@ await respecfully(sir, `when forking a regular ibgib`, async () => {
         iReckon(sir, newIbGib!.rel8ns!.ancestor).isGonnaBeTruthy();
         iReckon(sir, newIbGib!.rel8ns!.ancestor).isGonnaBeTruthy();
         const parentAddr = getIbGibAddr({ ibGib: parent });
+
         iReckon(sir, newIbGib!.rel8ns!.ancestor![newIbGib!.rel8ns!.ancestor!.length - 1]).isGonnaBe(parentAddr);
+
         iReckon(sir, newIbGib!.data).isGonnaBeTruthy();
-        iReckon(sir, newIbGib!.data).isGonnaBe(testData);
-    });
 
-    // it(`should clone data`, async () => {
-    // });
+        // 12/2024 - ok, I have changed fundamental gib hashing with
+        // normalization. this sorts keys and removes 'undefined' values
+        iReckon(sir, toNormalizedForHashing(newIbGib!.data)).isGonnaBe(toNormalizedForHashing(testData));
+    });
 });
 
 await respecfully(sir, `when forking multiple regular ibgibs, NON LINKED REL8NS`, async () => {
@@ -276,7 +288,7 @@ await respecfully(sir, `when forking multiple regular ibgibs, NON LINKED REL8NS`
     let srcForks: { [ib: string]: TransformResult<IbGib_V1> } = {};
     let srcIbGibs: { [ib: string]: IbGib_V1 } = {};
 
-    beforeEach(async () => {
+    firstOfEach(sir, async () => {
         // These will be the srcs we're working off of.
         // a forked from root, b forked from a, etc.
         let prevIbGib: IbGib_V1 | undefined;
@@ -287,7 +299,7 @@ await respecfully(sir, `when forking multiple regular ibgibs, NON LINKED REL8NS`
             prevIbGib = forkResult.newIbGib;
         }
     });
-    afterEach(() => {
+    lastOfEach(sir, () => {
         srcForks = {};
         srcIbGibs = {};
     })
@@ -319,7 +331,7 @@ await respecfully(sir, `when forking multiple regular ibgibs, NON LINKED REL8NS`
             iReckon(sir, newIbGib?.rel8ns).isGonnaBeTruthy();
             iReckon(sir, newIbGib?.rel8ns!.ancestor).isGonnaBeTruthy();
             iReckon(sir, newIbGib?.rel8ns!.ancestor).isGonnaBeTruthy();
-            iReckon(sir, newIbGib?.rel8ns!.ancestor!.length).toBeGreaterThan(0);
+            iReckon(sir, newIbGib?.rel8ns!.ancestor!.length > 0).isGonnaBeTrue();
             const prevIbGibAddr = getIbGibAddr({ ibGib: prevIbGib });
             iReckon(sir, newIbGib?.rel8ns!.ancestor![newIbGib!.rel8ns!.ancestor!.length - 1]).isGonnaBe(prevIbGibAddr);
         })
@@ -346,7 +358,7 @@ await respecfully(sir, `when forking with YES LINKED 'ancestor' rel8n...`, async
     let srcForks: { [ib: string]: TransformResult<IbGib_V1> } = {};
     let srcIbGibs: { [ib: string]: IbGib_V1 } = {};
 
-    beforeEach(async () => {
+    firstOfEach(sir, async () => {
         // These will be the srcs we're working off of.
         // a forked from root, b forked from a, etc.
         let prevIbGib: IbGib_V1 | undefined;
@@ -363,7 +375,7 @@ await respecfully(sir, `when forking with YES LINKED 'ancestor' rel8n...`, async
 
         }
     });
-    afterEach(() => {
+    lastOfEach(sir, () => {
         srcForks = {};
         srcIbGibs = {};
     })
@@ -390,7 +402,7 @@ await respecfully(sir, `when forking with YES LINKED 'ancestor' rel8n...`, async
         // the first one forks from the root, so the rel8ns should be undefined which is tested elsewhere
         ibs.filter(ib => ib === "a").forEach(ib => {
             const newIbGib = srcIbGibs[ib]!;
-            iReckon(sir, newIbGib?.rel8ns).toBeUndefined();
+            iReckon(sir, newIbGib?.rel8ns).isGonnaBeUndefined();
             // expect(newIbGib?.rel8ns!.ancestor).isGonnaBeTruthy();
             // expect(newIbGib?.rel8ns!.ancestor).isGonnaBeTruthy();
             // expect(newIbGib?.rel8ns!.ancestor!.length).isGonnaBe(1);

package/src/V1/transforms/mut8.mts

@@ -1,5 +1,5 @@
 import { getIbGibAddr } from '../../helper.mjs';
-import { clone, getTimestamp, } from '@ibgib/helper-gib';
+import { clone, getTimestamp, } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
 import { IbGib_V1, IbGibData_V1, IbGibRel8ns_V1, Rel8n } from '../types.mjs';
 import { TransformOpts_Mut8, TransformResult } from '../../types.mjs';
 import { IBGIB_DELIMITER, } from '../constants.mjs';

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

@@ -7,10 +7,17 @@
  *   going.
  */
 
+import { clone, delay, } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+import {
+    firstOfEach, firstOfAll, ifWe,
+    lastOfEach, lastOfAll,
+    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 } from '../types.mjs';
 import { TransformOpts_Mut8, IbGibAddr } from '../../types.mjs';
 import { getIbGibAddr, getIbAndGib, } from '../../helper.mjs';
-import { clone, delay, } from '@ibgib/helper-gib';
 import { sha256v1, } from '../sha256v1.mjs';
 import { ROOT } from '../constants.mjs';
 import { fork } from './fork.mjs';
@@ -53,7 +60,7 @@ await respecfully(sir, `can't mut8 primitives (including the root)`, async () =>
             } catch (error) {
                 errored = true;
             }
-            iReckon(sir, errored).toBeTrue()
+            iReckon(sir, errored).isGonnaBeTrue()
         });
 
         await ifWe(sir, `should fail to mut8 add or patch data (ib: ${src.ib})`, async () => {
@@ -63,7 +70,7 @@ await respecfully(sir, `can't mut8 primitives (including the root)`, async () =>
             } catch (error) {
                 errored = true;
             }
-            iReckon(sir, errored).toBeTrue()
+            iReckon(sir, errored).isGonnaBeTrue()
         });
 
         await ifWe(sir, `should fail to mut8 rename data (ib: ${src.ib})`, async () => {
@@ -73,7 +80,7 @@ await respecfully(sir, `can't mut8 primitives (including the root)`, async () =>
             } catch (error) {
                 errored = true;
             }
-            iReckon(sir, errored).toBeTrue()
+            iReckon(sir, errored).isGonnaBeTrue()
         });
 
         await ifWe(sir, `should fail to mut8 remove data (ib: ${src.ib})`, async () => {
@@ -83,7 +90,7 @@ await respecfully(sir, `can't mut8 primitives (including the root)`, async () =>
             } catch (error) {
                 errored = true;
             }
-            iReckon(sir, errored).toBeTrue()
+            iReckon(sir, errored).isGonnaBeTrue()
         });
     }
 });
@@ -145,7 +152,7 @@ await respecfully(sir, `when mutating a regular ibgib`, async () => {
                         .isGonnaBe(1);
 
                     // the data should have the new key name that we did
-                    iReckon(sir, Object.keys(dataRenamedIbGib.data!)).toContain(newNameForX);
+                    iReckon(sir, Object.keys(dataRenamedIbGib.data!)).includes(newNameForX);
 
                     // the data value for that new key name should be the same as before, since we didn't change it
                     iReckon(sir, dataRenamedIbGib.data![newNameForX]).isGonnaBe(valueForX);
@@ -185,7 +192,7 @@ await respecfully(sir, `when mutating a regular ibgib`, async () => {
                     iReckon(sir, dataRemovedIbGib.data).isGonnaBeTruthy();
 
                     // the data value for that new key name should be the same as before, since we didn't change it
-                    iReckon(sir, dataRemovedIbGib.data!.x).toBeUndefined();
+                    iReckon(sir, dataRemovedIbGib.data!.x).isGonnaBeUndefined();
 
                     // the most recent past of the dataRemovedIbGib should be the src's address
                     iReckon(sir, dataRemovedIbGib.rel8ns!.past![dataRemovedIbGib.rel8ns!.past!.length - 1]).isGonnaBe(dataAddedAddr);
@@ -212,7 +219,7 @@ await respecfully(sir, `when mutating a regular ibgib`, async () => {
                     const tjpAddr = getIbGibAddr({ ibGib: tjpIbGib });
                     const tjpAddrGib = getIbAndGib({ ibGibAddr: tjpAddr }).gib;
                     iReckon(sir, tjpIbGib!.data?.uuid).isGonnaBeTruthy();
-                    iReckon(sir, tjpIbGib!.data?.isTjp).asTo("isTjp").toBeTrue()
+                    iReckon(sir, tjpIbGib!.data?.isTjp).asTo("isTjp").isGonnaBeTrue()
                     const { newIbGib: hasRel8dTjp } = await mut8({
                         src: tjpIbGib,
                         dataToAddOrPatch: { someData: "not intrinsically pertinent to this test" },
@@ -220,25 +227,25 @@ await respecfully(sir, `when mutating a regular ibgib`, async () => {
                     const hasRel8dTjpAddr = getIbGibAddr({ ibGib: hasRel8dTjp });
                     const hasRel8dTjpAddrGib = getIbAndGib({ ibGibAddr: hasRel8dTjpAddr }).gib;
                     iReckon(sir, hasRel8dTjp!.data?.uuid).isGonnaBeTruthy();
-                    iReckon(sir, hasRel8dTjp!.data?.isTjp).asTo("isTjp after additional mut8").toBeUndefined();
+                    iReckon(sir, hasRel8dTjp!.data?.isTjp).asTo("isTjp after additional mut8").isGonnaBeUndefined();
                     iReckon(sir, hasRel8dTjp!.rel8ns).asTo("rel8ns").isGonnaBeTruthy();
                     iReckon(sir, hasRel8dTjp!.rel8ns!.tjp).asTo("rel8ns.tjp").isGonnaBeTruthy();
                     iReckon(sir, hasRel8dTjp!.rel8ns!.tjp!.length).asTo("rel8ns.tjp.length").isGonnaBe(1);
-                    iReckon(sir, hasRel8dTjp!.rel8ns!.tjp).asTo("rel8ns.tjp include").toContain(tjpAddr);
+                    iReckon(sir, hasRel8dTjp!.rel8ns!.tjp).asTo("rel8ns.tjp include").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
                     let 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);
                 });
             }
         } // double for..of statement
@@ -251,7 +258,7 @@ await respecfully(sir, `when mutating a regular ibgib`, async () => {
             patchDna: IbGib_V1, dataPatchedIbGib1: IbGib_V1,
             renameDna: IbGib_V1, dataRenamedIbGib1: IbGib_V1,
             removeDna: IbGib_V1, dataRemovedIbGib1: IbGib_V1;
-        beforeAll(async () => {
+        firstOfAll(sir, async () => {
             const resInit = await fork({ src: ROOT, dna: true });
             src = resInit.newIbGib;
             forkDnas = resInit.dnas!;
@@ -284,9 +291,9 @@ await respecfully(sir, `when mutating a regular ibgib`, async () => {
 
                 iReckon(sir, mut8DnaData).asTo(`should have well-formed common transform opts`).isGonnaBeTruthy();
                 iReckon(sir, mut8DnaData).asTo(`should have well-formed common transform opts`).isGonnaBeTruthy();
-                iReckon(sir, mut8DnaData.dna).asTo(`should have well-formed common transform opts`).toBeTrue()
-                iReckon(sir, mut8DnaData.srcAddr).asTo(`should have well-formed common transform opts`).toBeUndefined();
-                iReckon(sir, mut8DnaData.src).asTo(`should have well-formed common transform opts`).toBeUndefined();
+                iReckon(sir, mut8DnaData.dna).asTo(`should have well-formed common transform opts`).isGonnaBeTrue()
+                iReckon(sir, mut8DnaData.srcAddr).asTo(`should have well-formed common transform opts`).isGonnaBeUndefined();
+                iReckon(sir, mut8DnaData.src).asTo(`should have well-formed common transform opts`).isGonnaBeUndefined();
 
                 iReckon(sir, mut8DnaData.type).asTo(`should have well-formed data specific to type of mut8`).isGonnaBe("mut8");
                 iReckon(sir, mut8DnaData.dataToAddOrPatch).asTo(`should have well-formed data specific to type of mut8`).isGonnaBe(dataToAdd);
@@ -315,9 +322,9 @@ await respecfully(sir, `when mutating a regular ibgib`, async () => {
 
                 iReckon(sir, mut8DnaData).asTo(`data patched, should have well-formed common transform opts`).isGonnaBeTruthy();
                 iReckon(sir, mut8DnaData).asTo(`data patched, should have well-formed common transform opts`).isGonnaBeTruthy();
-                iReckon(sir, mut8DnaData.dna).asTo(`data patched, should have well-formed common transform opts`).toBeTrue()
-                iReckon(sir, mut8DnaData.srcAddr).asTo(`data patched, should have well-formed common transform opts`).toBeUndefined();
-                iReckon(sir, mut8DnaData.src).asTo(`data patched, should have well-formed common transform opts`).toBeUndefined();
+                iReckon(sir, mut8DnaData.dna).asTo(`data patched, should have well-formed common transform opts`).isGonnaBeTrue()
+                iReckon(sir, mut8DnaData.srcAddr).asTo(`data patched, should have well-formed common transform opts`).isGonnaBeUndefined();
+                iReckon(sir, mut8DnaData.src).asTo(`data patched, should have well-formed common transform opts`).isGonnaBeUndefined();
                 iReckon(sir, mut8DnaData.type).asTo(`data patched, should have well-formed data specific to type of mut8`).isGonnaBe("mut8");
                 iReckon(sir, mut8DnaData.dataToAddOrPatch).asTo(`data patched, should have well-formed data specific to type of mut8`).isGonnaBe(dataToPatch);
             }
@@ -344,9 +351,9 @@ await respecfully(sir, `when mutating a regular ibgib`, async () => {
 
                 iReckon(sir, mut8DnaData).asTo(`data renamed, should have well-formed common transform opts`).isGonnaBeTruthy();
                 iReckon(sir, mut8DnaData).asTo(`data renamed, should have well-formed common transform opts`).isGonnaBeTruthy();
-                iReckon(sir, mut8DnaData.dna).asTo(`data renamed, should have well-formed common transform opts`).toBeTrue()
-                iReckon(sir, mut8DnaData.srcAddr).asTo(`data renamed, should have well-formed common transform opts`).toBeUndefined();
-                iReckon(sir, mut8DnaData.src).asTo(`data renamed, should have well-formed common transform opts`).toBeUndefined();
+                iReckon(sir, mut8DnaData.dna).asTo(`data renamed, should have well-formed common transform opts`).isGonnaBeTrue()
+                iReckon(sir, mut8DnaData.srcAddr).asTo(`data renamed, should have well-formed common transform opts`).isGonnaBeUndefined();
+                iReckon(sir, mut8DnaData.src).asTo(`data renamed, should have well-formed common transform opts`).isGonnaBeUndefined();
 
                 iReckon(sir, mut8DnaData.type).asTo(`data renamed, should have well-formed data specific to type of mut8`).isGonnaBe("mut8");
                 iReckon(sir, mut8DnaData.dataToRename).asTo(`data renamed, should have well-formed data specific to type of mut8`).isGonnaBe(dataToRename);
@@ -375,9 +382,9 @@ await respecfully(sir, `when mutating a regular ibgib`, async () => {
 
                 iReckon(sir, mut8DnaData).asTo(`data removed, should have well-formed common transform opts`).isGonnaBeTruthy();
                 iReckon(sir, mut8DnaData).asTo(`data removed, should have well-formed common transform opts`).isGonnaBeTruthy();
-                iReckon(sir, mut8DnaData.dna).asTo(`data removed, should have well-formed common transform opts`).toBeTrue()
-                iReckon(sir, mut8DnaData.srcAddr).asTo(`data removed, should have well-formed common transform opts`).toBeUndefined();
-                iReckon(sir, mut8DnaData.src).asTo(`data removed, should have well-formed common transform opts`).toBeUndefined();
+                iReckon(sir, mut8DnaData.dna).asTo(`data removed, should have well-formed common transform opts`).isGonnaBeTrue()
+                iReckon(sir, mut8DnaData.srcAddr).asTo(`data removed, should have well-formed common transform opts`).isGonnaBeUndefined();
+                iReckon(sir, mut8DnaData.src).asTo(`data removed, should have well-formed common transform opts`).isGonnaBeUndefined();
 
                 iReckon(sir, mut8DnaData.type).asTo(`data removed, should have well-formed data specific to type of mut8`).isGonnaBe("mut8");
                 iReckon(sir, mut8DnaData.dataToRemove).asTo(`data removed, should have well-formed data specific to type of mut8`).isGonnaBe(dataToRemove);
@@ -511,7 +518,7 @@ await respecfully(sir, `when mutating a regular ibgib`, async () => {
 
                 // the data should have the new key name that we did
                 iReckon(sir, dataRenamedIbGib.data!.nested1).isGonnaBeTruthy();
-                iReckon(sir, dataRenamedIbGib.data!.nested1![RENAME_ME_KEY]).toBeUndefined();
+                iReckon(sir, dataRenamedIbGib.data!.nested1![RENAME_ME_KEY]).isGonnaBeUndefined();
                 iReckon(sir, dataRenamedIbGib.data!.nested1![RENAMED_KEY]).isGonnaBeTruthy();
 
                 // the data value for that new key name should be the same as before, since we didn't change it
@@ -554,7 +561,7 @@ await respecfully(sir, `when mutating a regular ibgib`, async () => {
 
                 // the data value for that new key name should be the same as before, since we didn't change it
                 iReckon(sir, dataRemovedIbGib.data!.xyObj).isGonnaBeTruthy();
-                iReckon(sir, dataRemovedIbGib.data!.xyObj!.x).toBeUndefined();
+                iReckon(sir, dataRemovedIbGib.data!.xyObj!.x).isGonnaBeUndefined();
 
                 // the most recent past of the dataRemovedIbGib should be the src's address
                 iReckon(sir, dataRemovedIbGib.rel8ns!.past![dataRemovedIbGib.rel8ns!.past!.length - 1]).isGonnaBe(dataAddedAddr);
@@ -592,7 +599,7 @@ await respecfully(sir, `when mutating a regular ibgib`, async () => {
                 let { newIbGib: src_0 } =
                     await fork({ src: primitive, noTimestamp: true });
 
-                iReckon(sir, src_0.data).toBeUndefined();
+                iReckon(sir, src_0.data).isGonnaBeUndefined();
 
                 let { newIbGib: src_1 } =
                     await mut8({
@@ -610,7 +617,7 @@ await respecfully(sir, `when mutating a regular ibgib`, async () => {
                 let { newIbGib: src_0 } =
                     await fork({ src: primitive, noTimestamp: true, nCounter: false });
 
-                iReckon(sir, src_0.data).toBeUndefined();
+                iReckon(sir, src_0.data).isGonnaBeUndefined();
 
                 let { newIbGib: src_1 } =
                     await mut8({

package/src/V1/transforms/rel8.mts

@@ -1,6 +1,5 @@
-import { getIbGibAddr, getIbAndGib } from '../../helper.mjs';
-import { pretty, clone, delay, getTimestamp, } from '@ibgib/helper-gib';
-import { sha256v1 } from '../sha256v1.mjs';
+import { getIbGibAddr, } from '../../helper.mjs';
+import { clone, getTimestamp, } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
 import { IbGib_V1, IbGibData_V1, IbGibRel8ns_V1, Rel8n } from '../types.mjs';
 import { TransformOpts_Rel8, TransformResult, IbGibAddr } from '../../types.mjs';
 import { IBGIB_DELIMITER, GIB, FORBIDDEN_ADD_RENAME_REMOVE_REL8N_NAMES } from '../constants.mjs';