@ibgib/ts-gib 0.5.0 → 0.5.2

package/src/V1/transforms/fork.spec.mts

@@ -25,31 +25,31 @@ import { ROOT, ROOT_ADDR } from '../constants.mjs';
 import { mut8 } from './mut8.mjs';
 import { getGib } from './transform-helper.mjs';
 
-describe(`when forking the root`, () => {
+await respecfully(sir, `when forking the root`, async () => {
 
     const src = ROOT;
 
-    it(`should create a new ibgib`, async () => {
+    await ifWe(sir, `should create a new ibgib`, async () => {
         const { newIbGib } = await fork({ src });
-        expect(newIbGib).toBeTruthy();
+        iReckon(sir, newIbGib).isGonnaBeTruthy();
     });
 
-    it(`should have no rel8ns (because forked from the root)`, async () => {
+    await ifWe(sir, `should have no rel8ns (because forked from the root)`, async () => {
         const { newIbGib } = await fork({ src });
-        expect(newIbGib.rel8ns).toBeUndefined();
+        iReckon(sir, newIbGib.rel8ns).toBeUndefined();
     });
 
-    describe(`should respect param`, () => {
-        it(`noTimestamp`, async () => {
+    await respecfully(sir, `should respect param`, async () => {
+        await ifWe(sir, `noTimestamp`, async () => {
             const { newIbGib } = await fork({ src, noTimestamp: true });
             if (newIbGib?.data) {
-                expect(newIbGib.data!.timestamp).toBeUndefined();
+                iReckon(sir, newIbGib.data!.timestamp).toBeUndefined();
             } else {
                 // data being falsy is passing so no expect statement needed
             }
         });
 
-        it(`destIb`, async () => {
+        await ifWe(sir, `destIb`, async () => {
             // just an example, ib can be any value/metadata per use case
             // in this example, we have a canonical form tag [tagName]
             // this way, we can just pass around the address (tag like ^ABCD123)
@@ -57,103 +57,103 @@ describe(`when forking the root`, () => {
             // entire data record.
             const destIb = 'tag like';
             const { newIbGib } = await fork({ src, destIb });
-            expect(newIbGib.ib).toEqual(destIb);
+            iReckon(sir, newIbGib.ib).isGonnaBe(destIb);
         });
 
-        it(`dna`, async () => {
+        await ifWe(sir, `dna`, async () => {
             // NOTE: more extensive dna testing is below in other tests
             const destIb = "This will be the new ib";
             const { newIbGib, dnas } = await fork({ src, dna: true, destIb });
-            expect(dnas).toBeTruthy();
+            iReckon(sir, dnas).isGonnaBeTruthy();
         });
 
-        it(`uuid`, async () => {
+        await ifWe(sir, `uuid`, async () => {
             const { newIbGib } = await fork({ src, uuid: true });
-            expect(newIbGib?.data).toBeTruthy();
-            expect(newIbGib!.data?.uuid).toBeTruthy();
+            iReckon(sir, newIbGib?.data).isGonnaBeTruthy();
+            iReckon(sir, newIbGib!.data?.uuid).isGonnaBeTruthy();
         });
 
-        describe(`tjp...`, () => {
-            it(`timestamp`, async () => {
+        await respecfully(sir, `tjp...`, async () => {
+            await ifWe(sir, `timestamp`, async () => {
                 const { newIbGib } = await fork({ src, tjp: { timestamp: true } });
-                expect(newIbGib?.data).toBeTruthy();
-                expect(newIbGib!.data?.timestamp).toBeTruthy();
+                iReckon(sir, newIbGib?.data).isGonnaBeTruthy();
+                iReckon(sir, newIbGib!.data?.timestamp).isGonnaBeTruthy();
                 const testDate = new Date(newIbGib!.data!.timestamp!);
-                expect(testDate).toBeTruthy();
-                expect(testDate).toBeTruthy();
-                expect(testDate.toString()).not.toEqual("Invalid Date");
+                iReckon(sir, testDate).isGonnaBeTruthy();
+                iReckon(sir, testDate).isGonnaBeTruthy();
+                iReckon(sir, testDate.toString()).not.isGonnaBe("Invalid Date");
                 // counting on environment (node) to be consistent with invalid dates in the future
                 const invalidDate = new Date("asdf");
-                expect(invalidDate.toString()).toEqual("Invalid Date");
-                expect(newIbGib!.data?.isTjp).withContext("isTjp").toBeTrue();
+                iReckon(sir, invalidDate.toString()).isGonnaBe("Invalid Date");
+                iReckon(sir, newIbGib!.data?.isTjp).asTo("isTjp").toBeTrue();
             });
-            it(`uuid`, async () => {
+            await ifWe(sir, `uuid`, async () => {
                 const { newIbGib } = await fork({ src, tjp: { uuid: true } });
-                expect(newIbGib?.data).toBeTruthy();
-                expect(newIbGib!.data?.uuid).toBeTruthy();
-                expect(newIbGib!.data?.isTjp).withContext("isTjp").toBeTrue()
+                iReckon(sir, newIbGib?.data).isGonnaBeTruthy();
+                iReckon(sir, newIbGib!.data?.uuid).isGonnaBeTruthy();
+                iReckon(sir, newIbGib!.data?.isTjp).asTo("isTjp").toBeTrue()
             });
-            it(`timestamp && uuid`, async () => {
+            await ifWe(sir, `timestamp && uuid`, async () => {
                 const { newIbGib } = await fork({ src, tjp: { timestamp: true, uuid: true } });
-                expect(newIbGib?.data).toBeTruthy();
-                expect(newIbGib!.data?.timestamp).toBeTruthy();
+                iReckon(sir, newIbGib?.data).isGonnaBeTruthy();
+                iReckon(sir, newIbGib!.data?.timestamp).isGonnaBeTruthy();
                 const testDate = new Date(newIbGib!.data!.timestamp!);
-                expect(testDate).toBeTruthy();
-                expect(testDate).toBeTruthy();
-                expect(testDate.toString()).not.toEqual("Invalid Date");
-                expect(newIbGib!.data?.uuid).toBeTruthy();
-                expect(newIbGib!.data?.isTjp).withContext("isTjp").toBeTrue()
+                iReckon(sir, testDate).isGonnaBeTruthy();
+                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()
             });
         });
 
-        it(`nCounter`, async () => {
+        await ifWe(sir, `nCounter`, async () => {
             const { newIbGib } = await fork({ src, nCounter: true });
-            expect(newIbGib?.data).toBeTruthy();
-            expect(newIbGib!.data?.n).toEqual(0);
+            iReckon(sir, newIbGib?.data).isGonnaBeTruthy();
+            iReckon(sir, newIbGib!.data?.n).isGonnaBe(0);
         });
 
 
-        it(`cloneRel8ns (setting should be ignored since forking root)`, async () => {
+        await ifWe(sir, `cloneRel8ns (setting should be ignored since forking root)`, async () => {
             const { newIbGib } = await fork({ src, cloneRel8ns: true, noTimestamp: true });
-            expect(newIbGib?.rel8ns).toBeUndefined();
+            iReckon(sir, newIbGib?.rel8ns).toBeUndefined();
         });
 
-        it(`cloneData (setting should be ignored since forking root)`, async () => {
+        await ifWe(sir, `cloneData (setting should be ignored since forking root)`, async () => {
             const { newIbGib } = await fork({ src, cloneData: true, noTimestamp: true });
-            expect(newIbGib?.data).toBeUndefined();
+            iReckon(sir, newIbGib?.data).toBeUndefined();
         });
     });
 
-    describe(`...and creating dna`, () => {
-        it(`should have well-formed dna, like...`, async () => {
+    await respecfully(sir, `...and creating dna`, async () => {
+        await ifWe(sir, `should have well-formed dna, like...`, async () => {
             const destIb = "This will be the new ib";
             const { newIbGib, intermediateIbGibs, dnas } = await fork({ src, dna: true, destIb });
             const forkDna = dnas![0];
 
-            expect(forkDna.ib).withContext(`ib should be fork`).toEqual('fork');
+            iReckon(sir, forkDna.ib).asTo(`ib should be fork`).isGonnaBe('fork');
 
             let ibGibs = [newIbGib, ...(intermediateIbGibs ?? []), ...(dnas ?? [])];
             for (let i = 0; i < ibGibs.length; i++) {
                 const ibGib = ibGibs[i];
                 let gottenGib = await getGib({ ibGib });
-                expect(ibGib.gib).withContext(`should have a gib that is corroborated with getGib`).toEqual(gottenGib);
+                iReckon(sir, ibGib.gib).asTo(`should have a gib that is corroborated with getGib`).isGonnaBe(gottenGib);
             }
 
-            expect(forkDna?.rel8ns).withContext(`should descend from fork^gib primitive`).toBeTruthy();
+            iReckon(sir, forkDna?.rel8ns).asTo(`should descend from fork^gib primitive`).isGonnaBeTruthy();
             const forkDnaRel8ns: IbGibRel8ns_V1 = forkDna?.rel8ns!;
-            expect(forkDnaRel8ns.ancestor).withContext(`should descend from fork^gib primitive`).toBeTruthy();
-            expect(forkDnaRel8ns.ancestor!.length).withContext(`should descend from fork^gib primitive`).toEqual(1);
-            expect(forkDnaRel8ns.ancestor![0]).withContext(`should descend from fork^gib primitive`).toEqual('fork^gib');
+            iReckon(sir, forkDnaRel8ns.ancestor).asTo(`should descend from fork^gib primitive`).isGonnaBeTruthy();
+            iReckon(sir, forkDnaRel8ns.ancestor!.length).asTo(`should descend from fork^gib primitive`).isGonnaBe(1);
+            iReckon(sir, forkDnaRel8ns.ancestor![0]).asTo(`should descend from fork^gib primitive`).isGonnaBe('fork^gib');
 
             const forkDnaData = (forkDna.data as TransformOpts_Fork<IbGib_V1>)!;
 
-            expect(forkDna.data).withContext(`should have well-formed common transform opts`).toBeTruthy();
-            expect(forkDnaData.dna).withContext(`should have well-formed common transform opts`).toBeTrue()
-            expect(forkDnaData.srcAddr).withContext(`should have well-formed common transform opts`).toBeUndefined();
-            expect(forkDnaData.src).withContext(`should have well-formed common transform opts`).toBeUndefined();
+            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();
 
-            expect(forkDnaData.type).withContext(`should have well-formed data specific to fork transform`).toEqual("fork");
-            expect(forkDnaData.destIb).withContext(`should have well-formed data specific to fork transform`).toEqual(destIb);
+            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);
 
             // we're going to do another fork with the same options gotten from the dna
             // (kinda like translating a foreign language translation back into the
@@ -170,26 +170,26 @@ describe(`when forking the root`, () => {
             const forkOpts2: TransformOpts_Fork<IbGib_V1> = clone(forkDnaData);
             forkOpts2.src = ROOT;
             const { newIbGib: newIbGib2, dnas: dnas2 } = await fork(forkOpts2);
-            expect(newIbGib2).withContext(`should produce pure dna function, and non-unique dna (without timestamps, tjp, or uuid) (1s delay)`).toBeTruthy();
-            expect(dnas2).withContext(`should produce pure dna function, and non-unique dna (without timestamps, tjp, or uuid) (1s delay)`).toBeTruthy();
+            iReckon(sir, newIbGib2).asTo(`should produce pure dna function, and non-unique dna (without timestamps, tjp, or uuid) (1s delay)`).isGonnaBeTruthy();
+            iReckon(sir, dnas2).asTo(`should produce pure dna function, and non-unique dna (without timestamps, tjp, or uuid) (1s delay)`).isGonnaBeTruthy();
             const forkDna2 = dnas2![0];
 
             // dna itself should be exactly the same
-            expect(forkDna2).withContext(`should produce pure dna function, and non-unique dna (without timestamps, tjp, or uuid) (1s delay)`).toEqual(forkDna);
+            iReckon(sir, forkDna2).asTo(`should produce pure dna function, and non-unique dna (without timestamps, tjp, or uuid) (1s delay)`).isGonnaBe(forkDna);
 
             // the ibGibs **created** should NOT be the same because of timestamping
             // (and later on, other factors would change like identity and other rel8ns)
-            expect(newIbGib2.gib).withContext(`should produce pure dna function, and non-unique dna (without timestamps, tjp, or uuid) (1s delay)`).not.toEqual(newIbGib.gib);
+            iReckon(sir, newIbGib2.gib).asTo(`should produce pure dna function, and non-unique dna (without timestamps, tjp, or uuid) (1s delay)`).not.isGonnaBe(newIbGib.gib);
 
             // when forking using the same options, the ib should be the same
-            expect(newIbGib2.ib).withContext(`should produce pure dna function, and non-unique dna (without timestamps, tjp, or uuid) (1s delay)`).toEqual(newIbGib.ib);
+            iReckon(sir, newIbGib2.ib).asTo(`should produce pure dna function, and non-unique dna (without timestamps, tjp, or uuid) (1s delay)`).isGonnaBe(newIbGib.ib);
         });
     }); // dna
 
 });
 
 
-describe(`when forking a regular ibgib`, () => {
+await respecfully(sir, `when forking a regular ibgib`, async () => {
 
     let src: IbGib_V1;
     let srcAddr: IbGibAddr;
@@ -199,23 +199,23 @@ describe(`when forking a regular ibgib`, () => {
         const beforeResult = await fork({ src: ROOT, uuid: true });
         src = beforeResult.newIbGib;
 
-        expect(src).toBeTruthy();
+        iReckon(sir, src).isGonnaBeTruthy();
     });
 
-    it(`should create a new ibgib`, async () => {
+    await ifWe(sir, `should create a new ibgib`, async () => {
         const { newIbGib } = await fork({ src });
-        expect(newIbGib).toBeTruthy();
+        iReckon(sir, newIbGib).isGonnaBeTruthy();
     });
 
-    it(`should have src ib^gib address in ancestor rel8n`, async () => {
+    await ifWe(sir, `should have src ib^gib address in ancestor rel8n`, async () => {
         const { newIbGib } = await fork({ src });
-        expect(newIbGib?.rel8ns).toBeTruthy();
-        expect(newIbGib?.rel8ns).toBeTruthy();
-        expect(newIbGib?.rel8ns!.ancestor).toBeTruthy();
-        expect(newIbGib?.rel8ns!.ancestor).toBeTruthy();
-        expect(newIbGib?.rel8ns!.ancestor!.length).toEqual(1);
+        iReckon(sir, newIbGib?.rel8ns).isGonnaBeTruthy();
+        iReckon(sir, newIbGib?.rel8ns).isGonnaBeTruthy();
+        iReckon(sir, newIbGib?.rel8ns!.ancestor).isGonnaBeTruthy();
+        iReckon(sir, newIbGib?.rel8ns!.ancestor).isGonnaBeTruthy();
+        iReckon(sir, newIbGib?.rel8ns!.ancestor!.length).isGonnaBe(1);
         srcAddr = getIbGibAddr({ ibGib: src });
-        expect(newIbGib?.rel8ns!.ancestor![0]).toEqual(srcAddr);
+        iReckon(sir, newIbGib?.rel8ns!.ancestor![0]).isGonnaBe(srcAddr);
     });
 
     // TODO: TEST FORK cloneRel8ns option ONCE REL8 IS IMPLEMENTED
@@ -225,18 +225,18 @@ describe(`when forking a regular ibgib`, () => {
     //     const { newIbGib: parent } = await mut8({ src: grandparent, dataToAddOrPatch: testData });
     //     const { newIbGib } = await fork({ src: parent, cloneData: true});
 
-    //     expect(newIbGib).toBeTruthy();
-    //     expect(newIbGib!.rel8ns).toBeTruthy();
-    //     expect(newIbGib!.rel8ns).toBeTruthy();
-    //     expect(newIbGib!.rel8ns!.ancestor).toBeTruthy();
-    //     expect(newIbGib!.rel8ns!.ancestor).toBeTruthy();
+    //     expect(newIbGib).isGonnaBeTruthy();
+    //     expect(newIbGib!.rel8ns).isGonnaBeTruthy();
+    //     expect(newIbGib!.rel8ns).isGonnaBeTruthy();
+    //     expect(newIbGib!.rel8ns!.ancestor).isGonnaBeTruthy();
+    //     expect(newIbGib!.rel8ns!.ancestor).isGonnaBeTruthy();
     //     const parentAddr = getIbGibAddr({ibGib: parent});
-    //     expect(newIbGib!.rel8ns!.ancestor![newIbGib!.rel8ns!.ancestor!.length-1]).toEqual(parentAddr);
-    //     expect(newIbGib!.data).toBeTruthy();
-    //     expect(newIbGib!.data).toEqual(testData);
+    //     expect(newIbGib!.rel8ns!.ancestor![newIbGib!.rel8ns!.ancestor!.length-1]).isGonnaBe(parentAddr);
+    //     expect(newIbGib!.data).isGonnaBeTruthy();
+    //     expect(newIbGib!.data).isGonnaBe(testData);
     // });
 
-    it(`cloneData`, async () => {
+    await ifWe(sir, `cloneData`, async () => {
         // adding uuid/timestamp for testing hack
         // need to reconsider inability to rename/remove timestamp data
         // seems silly since bad actors can always do this and security is
@@ -253,22 +253,22 @@ describe(`when forking a regular ibgib`, () => {
             });
         const { newIbGib } = await fork({ src: parent, cloneData: true, noTimestamp: true });
 
-        expect(newIbGib).toBeTruthy();
-        expect(newIbGib!.rel8ns).toBeTruthy();
-        expect(newIbGib!.rel8ns).toBeTruthy();
-        expect(newIbGib!.rel8ns!.ancestor).toBeTruthy();
-        expect(newIbGib!.rel8ns!.ancestor).toBeTruthy();
+        iReckon(sir, newIbGib).isGonnaBeTruthy();
+        iReckon(sir, newIbGib!.rel8ns).isGonnaBeTruthy();
+        iReckon(sir, newIbGib!.rel8ns).isGonnaBeTruthy();
+        iReckon(sir, newIbGib!.rel8ns!.ancestor).isGonnaBeTruthy();
+        iReckon(sir, newIbGib!.rel8ns!.ancestor).isGonnaBeTruthy();
         const parentAddr = getIbGibAddr({ ibGib: parent });
-        expect(newIbGib!.rel8ns!.ancestor![newIbGib!.rel8ns!.ancestor!.length - 1]).toEqual(parentAddr);
-        expect(newIbGib!.data).toBeTruthy();
-        expect(newIbGib!.data).toEqual(testData);
+        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 () => {
     // });
 });
 
-describe(`when forking multiple regular ibgibs, NON LINKED REL8NS`, () => {
+await respecfully(sir, `when forking multiple regular ibgibs, NON LINKED REL8NS`, async () => {
 
     const ibs: Ib[] = ["a", "b", "c", "d"];
     let srcForks: { [ib: string]: TransformResult<IbGib_V1> } = {};
@@ -290,16 +290,16 @@ describe(`when forking multiple regular ibgibs, NON LINKED REL8NS`, () => {
         srcIbGibs = {};
     })
 
-    it(`should create a new ibgib`, async () => {
+    await ifWe(sir, `should create a new ibgib`, async () => {
         ibs.forEach(ib => {
             const ibGib = srcIbGibs[ib];
-            expect(ibGib).toBeTruthy();
-            expect(ibGib).toBeTruthy();
-            expect(ibGib.ib).toEqual(ib);
+            iReckon(sir, ibGib).isGonnaBeTruthy();
+            iReckon(sir, ibGib).isGonnaBeTruthy();
+            iReckon(sir, ibGib.ib).isGonnaBe(ib);
         })
     });
 
-    it(`should have src ib^gib (address) in ancestor rel8n`, async () => {
+    await ifWe(sir, `should have src ib^gib (address) in ancestor rel8n`, async () => {
         const getPrev: (ib: Ib) => IbGib_V1 | null = (ib) => {
             switch (ib) {
                 case "a": return null;
@@ -313,13 +313,13 @@ describe(`when forking multiple regular ibgibs, NON LINKED REL8NS`, () => {
         ibs.filter(ib => ib !== "a").forEach(ib => {
             const newIbGib = srcIbGibs[ib]!;
             const prevIbGib = getPrev(ib)!;
-            expect(newIbGib?.rel8ns).toBeTruthy();
-            expect(newIbGib?.rel8ns).toBeTruthy();
-            expect(newIbGib?.rel8ns!.ancestor).toBeTruthy();
-            expect(newIbGib?.rel8ns!.ancestor).toBeTruthy();
-            expect(newIbGib?.rel8ns!.ancestor!.length).toBeGreaterThan(0);
+            iReckon(sir, newIbGib?.rel8ns).isGonnaBeTruthy();
+            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);
             const prevIbGibAddr = getIbGibAddr({ ibGib: prevIbGib });
-            expect(newIbGib?.rel8ns!.ancestor![newIbGib!.rel8ns!.ancestor!.length - 1]).toEqual(prevIbGibAddr);
+            iReckon(sir, newIbGib?.rel8ns!.ancestor![newIbGib!.rel8ns!.ancestor!.length - 1]).isGonnaBe(prevIbGibAddr);
         })
     });
 
@@ -328,17 +328,17 @@ describe(`when forking multiple regular ibgibs, NON LINKED REL8NS`, () => {
     //     throw new Error('not implemented yet');
     //     const testData = { yo: "there" }
     //     const { newIbGib } = await fork({ src });
-    //     expect(newIbGib?.rel8ns).toBeTruthy();
-    //     expect(newIbGib?.rel8ns).toBeTruthy();
-    //     expect(newIbGib?.rel8ns!.ancestor).toBeTruthy();
-    //     expect(newIbGib?.rel8ns!.ancestor).toBeTruthy();
-    //     expect(newIbGib?.rel8ns!.ancestor!.length).toEqual(1);
+    //     expect(newIbGib?.rel8ns).isGonnaBeTruthy();
+    //     expect(newIbGib?.rel8ns).isGonnaBeTruthy();
+    //     expect(newIbGib?.rel8ns!.ancestor).isGonnaBeTruthy();
+    //     expect(newIbGib?.rel8ns!.ancestor).isGonnaBeTruthy();
+    //     expect(newIbGib?.rel8ns!.ancestor!.length).isGonnaBe(1);
     //     srcAddr = getIbGibAddr({ibGib: src});
-    //     expect(newIbGib?.rel8ns!.ancestor![0]).toEqual(srcAddr);
+    //     expect(newIbGib?.rel8ns!.ancestor![0]).isGonnaBe(srcAddr);
     // });
 });
 
-describe(`when forking with YES LINKED 'ancestor' rel8n...`, () => {
+await respecfully(sir, `when forking with YES LINKED 'ancestor' rel8n...`, async () => {
 
     const ibs: Ib[] = ["a", "b", "c", "d"];
     let srcForks: { [ib: string]: TransformResult<IbGib_V1> } = {};
@@ -366,16 +366,16 @@ describe(`when forking with YES LINKED 'ancestor' rel8n...`, () => {
         srcIbGibs = {};
     })
 
-    it(`should create a new ibgib`, async () => {
+    await ifWe(sir, `should create a new ibgib`, async () => {
         ibs.forEach(ib => {
             const ibGib = srcIbGibs[ib];
-            expect(ibGib).toBeTruthy();
-            expect(ibGib).toBeTruthy();
-            expect(ibGib.ib).toEqual(ib);
+            iReckon(sir, ibGib).isGonnaBeTruthy();
+            iReckon(sir, ibGib).isGonnaBeTruthy();
+            iReckon(sir, ibGib.ib).isGonnaBe(ib);
         })
     });
 
-    it(`should have src ib^gib (address) in ancestor rel8n`, async () => {
+    await ifWe(sir, `should have src ib^gib (address) in ancestor rel8n`, async () => {
         const getPrevIbGib: (ib: Ib) => IbGib_V1 | null = (ib) => {
             switch (ib) {
                 case "a": return null;
@@ -388,24 +388,24 @@ describe(`when forking with YES LINKED 'ancestor' rel8n...`, () => {
         // 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]!;
-            expect(newIbGib?.rel8ns).toBeUndefined();
-            // expect(newIbGib?.rel8ns!.ancestor).toBeTruthy();
-            // expect(newIbGib?.rel8ns!.ancestor).toBeTruthy();
-            // expect(newIbGib?.rel8ns!.ancestor!.length).toEqual(1);
+            iReckon(sir, newIbGib?.rel8ns).toBeUndefined();
+            // expect(newIbGib?.rel8ns!.ancestor).isGonnaBeTruthy();
+            // expect(newIbGib?.rel8ns!.ancestor).isGonnaBeTruthy();
+            // expect(newIbGib?.rel8ns!.ancestor!.length).isGonnaBe(1);
             // const prevIbGibAddr = getIbGibAddr({ibGib: prevIbGib});
-            // expect(newIbGib?.rel8ns!.ancestor![0]).toEqual(prevIbGibAddr);
+            // expect(newIbGib?.rel8ns!.ancestor![0]).isGonnaBe(prevIbGibAddr);
         });
         ibs.filter(ib => ib !== "a").forEach(ib => {
             const newIbGib = srcIbGibs[ib]!;
             const prevIbGib = getPrevIbGib(ib)!;
-            expect(newIbGib?.rel8ns).toBeTruthy();
-            expect(newIbGib?.rel8ns).toBeTruthy();
-            expect(newIbGib?.rel8ns!.ancestor).toBeTruthy();
-            expect(newIbGib?.rel8ns!.ancestor).toBeTruthy();
-            expect(newIbGib?.rel8ns!.ancestor!.length).toEqual(1);
+            iReckon(sir, newIbGib?.rel8ns).isGonnaBeTruthy();
+            iReckon(sir, newIbGib?.rel8ns).isGonnaBeTruthy();
+            iReckon(sir, newIbGib?.rel8ns!.ancestor).isGonnaBeTruthy();
+            iReckon(sir, newIbGib?.rel8ns!.ancestor).isGonnaBeTruthy();
+            iReckon(sir, newIbGib?.rel8ns!.ancestor!.length).isGonnaBe(1);
             const prevIbGibAddr = getIbGibAddr({ ibGib: prevIbGib });
-            expect(newIbGib?.rel8ns!.ancestor![0]).toEqual(prevIbGibAddr);
+            iReckon(sir, newIbGib?.rel8ns!.ancestor![0]).isGonnaBe(prevIbGibAddr);
         });
     });
 
-});
+});

package/src/V1/transforms/index.mts

@@ -1,4 +1,4 @@
 export * from './fork.mjs';
 export * from './mut8.mjs';
 export * from './rel8.mjs';
-export { isPrimitive, isDna } from './transform-helper.mjs';
+export * from './transform-helper.mjs';