@ibgib/ts-gib 0.5.1 → 0.5.2

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

@@ -73,10 +73,10 @@ function buildRel8nsToAddOrRemoveFromPrimitives(rel8nNames: string[]): IbGibRel8
     return result;
 }
 
-describe(`can't rel8 primitives to others`, () => {
+await respecfully(sir, `can't rel8 primitives to others`, async () => {
     for (const src of PRIMITIVE_IBGIBS) {
 
-        it(`should fail to add rel8ns`, async () => {
+        await ifWe(sir, `should fail to add rel8ns`, async () => {
             let errored = false;
             try {
                 const rel8nsToAddByAddr = buildRel8nsToAddOrRemoveFromPrimitives(SIMPLE_REL8N_NAMES);
@@ -84,10 +84,10 @@ describe(`can't rel8 primitives to others`, () => {
             } catch (error) {
                 errored = true;
             }
-            expect(errored).toBeTrue()
+            iReckon(sir, errored).toBeTrue()
         });
 
-        it(`should fail to remove rel8ns`, async () => {
+        await ifWe(sir, `should fail to remove rel8ns`, async () => {
             let errored = false;
             try {
                 const rel8nsToRemoveByAddr = buildRel8nsToAddOrRemoveFromPrimitives(SIMPLE_REL8N_NAMES);
@@ -95,10 +95,10 @@ describe(`can't rel8 primitives to others`, () => {
             } catch (error) {
                 errored = true;
             }
-            expect(errored).toBeTrue()
+            iReckon(sir, errored).toBeTrue()
         });
 
-        it(`should fail to add and remove rel8ns`, async () => {
+        await ifWe(sir, `should fail to add and remove rel8ns`, async () => {
             let errored = false;
             try {
                 const rel8nsToAddByAddr =
@@ -109,18 +109,18 @@ describe(`can't rel8 primitives to others`, () => {
             } catch (error) {
                 errored = true;
             }
-            expect(errored).toBeTrue()
+            iReckon(sir, errored).toBeTrue()
         });
 
     }
 });
 
-describe(`when rel8ing a regular ibgib`, () => {
+await respecfully(sir, `when rel8ing a regular ibgib`, async () => {
 
-    describe(`simple rel8ns to 1st gens (from primitives)`, () => {
+    await respecfully(sir, `simple rel8ns to 1st gens (from primitives)`, async () => {
         for (const primitive of PRIMITIVE_IBGIBS) {
 
-            it(`should add/remove simple rel8ns`, async () => {
+            await ifWe(sir, `should add/remove simple rel8ns`, async () => {
 
                 let { newIbGib: src } = await fork({ src: primitive, noTimestamp: true });
 
@@ -133,18 +133,18 @@ describe(`when rel8ing a regular ibgib`, () => {
 
                 const { newIbGib: rel8nsAddedIbGib } =
                     await rel8({ src, rel8nsToAddByAddr, noTimestamp: true });
-                expect(rel8nsAddedIbGib).toBeTruthy();
-                expect(rel8nsAddedIbGib.rel8ns).toBeTruthy();
-                expect(rel8nsAddedIbGib.rel8ns).toBeTruthy();
+                iReckon(sir, rel8nsAddedIbGib).isGonnaBeTruthy();
+                iReckon(sir, rel8nsAddedIbGib.rel8ns).isGonnaBeTruthy();
+                iReckon(sir, rel8nsAddedIbGib.rel8ns).isGonnaBeTruthy();
                 const rel8nNames_AddedIbGib = Object.keys(rel8nsAddedIbGib.rel8ns!);
                 SIMPLE_REL8N_NAMES.forEach(simpleRel8nName => {
-                    expect(rel8nNames_AddedIbGib).toContain(simpleRel8nName);
+                    iReckon(sir, rel8nNames_AddedIbGib).toContain(simpleRel8nName);
                     const simpleRel8nAddrs = rel8nsAddedIbGib.rel8ns![simpleRel8nName]!;
                     // expect(simpleRel8nAddrs).not.toHaveSize(0);
-                    expect(simpleRel8nAddrs).not.toHaveSize(0);
+                    iReckon(sir, simpleRel8nAddrs).not.toHaveSize(0);
                     const expectedRel8nAddrs = rel8nsToAddByAddr[simpleRel8nName];
-                    expect(expectedRel8nAddrs).not.toHaveSize(0);
-                    expect(simpleRel8nAddrs).toEqual(expectedRel8nAddrs!);
+                    iReckon(sir, expectedRel8nAddrs).not.toHaveSize(0);
+                    iReckon(sir, simpleRel8nAddrs).isGonnaBe(expectedRel8nAddrs!);
                 });
 
                 // #endregion
@@ -158,9 +158,9 @@ describe(`when rel8ing a regular ibgib`, () => {
 
                 const { newIbGib: rel8nsRemovedIbGib } =
                     await rel8({ src: rel8nsAddedIbGib, rel8nsToRemoveByAddr, noTimestamp: true });
-                expect(rel8nsRemovedIbGib).toBeTruthy();
-                expect(rel8nsRemovedIbGib.rel8ns).toBeTruthy();
-                expect(rel8nsRemovedIbGib.rel8ns).toBeTruthy();
+                iReckon(sir, rel8nsRemovedIbGib).isGonnaBeTruthy();
+                iReckon(sir, rel8nsRemovedIbGib.rel8ns).isGonnaBeTruthy();
+                iReckon(sir, rel8nsRemovedIbGib.rel8ns).isGonnaBeTruthy();
 
                 SIMPLE_REL8N_NAMES.forEach(simpleRel8nName => {
                     const rel8dAddrs = rel8nsRemovedIbGib.rel8ns![simpleRel8nName]!;
@@ -189,7 +189,7 @@ describe(`when rel8ing a regular ibgib`, () => {
               * then for src2, we'll make the call from the dna generated from the src1 transforms.
               * both should make the same transformations with regards to the rel8ns added/removed.
              */
-            it(`should create pure, reproducible dna`, async () => {
+            await ifWe(sir, `should create pure, reproducible dna`, async () => {
 
                 const ib1 = 'ib 1 yo';
                 let { newIbGib: src1 } = await fork({ src: primitive, noTimestamp: true, destIb: ib1 });
@@ -206,19 +206,19 @@ describe(`when rel8ing a regular ibgib`, () => {
 
                 const { newIbGib: rel8nsAddedIbGib, intermediateIbGibs, dnas: dnasRel8Add } =
                     await rel8({ src: src1, rel8nsToAddByAddr, noTimestamp: true, dna: true });
-                expect(dnasRel8Add).toBeTruthy();
-                expect(dnasRel8Add).toBeTruthy();
+                iReckon(sir, dnasRel8Add).isGonnaBeTruthy();
+                iReckon(sir, dnasRel8Add).isGonnaBeTruthy();
                 // ATOW dna only produces 1
                 const rel8DnaAdd = dnasRel8Add![0];
                 const rel8DnaDataAdd: TransformOpts_Rel8<IbGib_V1> = clone(rel8DnaAdd.data!);
                 const rel8nNames_AddedIbGib = Object.keys(rel8nsAddedIbGib.rel8ns!);
                 SIMPLE_REL8N_NAMES.forEach(simpleRel8nName => {
-                    expect(rel8nNames_AddedIbGib).toContain(simpleRel8nName);
+                    iReckon(sir, rel8nNames_AddedIbGib).toContain(simpleRel8nName);
                     const simpleRel8nAddrs = rel8nsAddedIbGib.rel8ns![simpleRel8nName]!;
-                    expect(simpleRel8nAddrs).not.toHaveSize(0);
+                    iReckon(sir, simpleRel8nAddrs).not.toHaveSize(0);
                     const expectedRel8nAddrs = rel8nsToAddByAddr[simpleRel8nName];
-                    expect(expectedRel8nAddrs).not.toHaveSize(0);
-                    expect(simpleRel8nAddrs).toEqual(expectedRel8nAddrs!);
+                    iReckon(sir, expectedRel8nAddrs).not.toHaveSize(0);
+                    iReckon(sir, simpleRel8nAddrs).isGonnaBe(expectedRel8nAddrs!);
                 });
 
                 // rerun the same rel8 call, but get the args from the dna of the
@@ -230,12 +230,12 @@ describe(`when rel8ing a regular ibgib`, () => {
                     await rel8(rel8DnaDataAdd);
                 const rel8nNames_AddedIbGib2 = Object.keys(rel8nsAddedIbGib2.rel8ns!);
                 SIMPLE_REL8N_NAMES.forEach(simpleRel8nName => {
-                    expect(rel8nNames_AddedIbGib2).toContain(simpleRel8nName);
+                    iReckon(sir, rel8nNames_AddedIbGib2).toContain(simpleRel8nName);
                     const simpleRel8nAddrs = rel8nsAddedIbGib2.rel8ns![simpleRel8nName]!;
-                    expect(simpleRel8nAddrs).not.toHaveSize(0);
+                    iReckon(sir, simpleRel8nAddrs).not.toHaveSize(0);
                     const expectedRel8nAddrs = rel8nsToAddByAddr[simpleRel8nName];
-                    expect(expectedRel8nAddrs).not.toHaveSize(0);
-                    expect(simpleRel8nAddrs).toEqual(expectedRel8nAddrs!);
+                    iReckon(sir, expectedRel8nAddrs).not.toHaveSize(0);
+                    iReckon(sir, simpleRel8nAddrs).isGonnaBe(expectedRel8nAddrs!);
                 });
 
                 // #endregion
@@ -298,15 +298,15 @@ describe(`when rel8ing a regular ibgib`, () => {
                 //#endregion
             });
 
-            it(`should rel8 linked rel8ns to make only one rel8n`, async () => {
+            await ifWe(sir, `should rel8 linked rel8ns to make only one rel8n`, async () => {
                 // linkedRel8ns should produce a rel8n that only has one target
                 let testRel8nName = 'test';
                 let { newIbGib: src1 } =
                     await fork({ src: primitive, linkedRel8ns: ['past', 'ancestor'] });
                 let src1Addr = getIbGibAddr({ ibGib: src1 });
-                expect((src1?.rel8ns?.past || []).length).withContext('src1.rel8ns.past.length').toEqual(0);
+                iReckon(sir, (src1?.rel8ns?.past || []).length).asTo('src1.rel8ns.past.length').isGonnaBe(0);
                 if (primitive.ib !== 'ib') {
-                    expect((src1?.rel8ns?.ancestor || []).length).withContext('src1.rel8ns.ancestor.length').toEqual(1);
+                    iReckon(sir, (src1?.rel8ns?.ancestor || []).length).asTo('src1.rel8ns.ancestor.length').isGonnaBe(1);
                 }
 
                 let { newIbGib: src2 } =
@@ -315,12 +315,12 @@ describe(`when rel8ing a regular ibgib`, () => {
                         rel8nsToAddByAddr: { [testRel8nName]: ['a^gib'] },
                         linkedRel8ns: ['past', 'ancestor', testRel8nName],
                     });
-                expect((src2?.rel8ns?.past || []).length).withContext('src2.rel8ns.past.length').toEqual(1);
+                iReckon(sir, (src2?.rel8ns?.past || []).length).asTo('src2.rel8ns.past.length').isGonnaBe(1);
                 if (primitive.ib !== 'ib') {
-                    expect((src2?.rel8ns?.ancestor || []).length).withContext('src2.rel8ns.ancestor.length').toEqual(1);
+                    iReckon(sir, (src2?.rel8ns?.ancestor || []).length).asTo('src2.rel8ns.ancestor.length').isGonnaBe(1);
                 }
-                expect((src2?.rel8ns![testRel8nName] || []).length).withContext(`src2.rel8ns.${testRel8nName}.length`).toEqual(1);
-                expect(src2?.rel8ns![testRel8nName]![0]).withContext(`src2.rel8ns.${testRel8nName}[0]`).toEqual('a^gib');
+                iReckon(sir, (src2?.rel8ns![testRel8nName] || []).length).asTo(`src2.rel8ns.${testRel8nName}.length`).isGonnaBe(1);
+                iReckon(sir, src2?.rel8ns![testRel8nName]![0]).asTo(`src2.rel8ns.${testRel8nName}[0]`).isGonnaBe('a^gib');
 
                 let { newIbGib: src3 } =
                     await rel8({
@@ -328,16 +328,16 @@ describe(`when rel8ing a regular ibgib`, () => {
                         rel8nsToAddByAddr: { [testRel8nName]: ['b^gib'] },
                         linkedRel8ns: ['past', 'ancestor', testRel8nName],
                     });
-                expect((src3?.rel8ns?.past || []).length).withContext('src3.rel8ns.past.length').toEqual(1);
+                iReckon(sir, (src3?.rel8ns?.past || []).length).asTo('src3.rel8ns.past.length').isGonnaBe(1);
                 if (primitive.ib !== 'ib') {
-                    expect((src3?.rel8ns?.ancestor || []).length).withContext('src3.rel8ns.ancestor.length').toEqual(1);
+                    iReckon(sir, (src3?.rel8ns?.ancestor || []).length).asTo('src3.rel8ns.ancestor.length').isGonnaBe(1);
                 }
-                expect((src3?.rel8ns![testRel8nName] || []).length).withContext(`src3.rel8ns.${testRel8nName}.length`).toEqual(1);
-                expect(src3?.rel8ns![testRel8nName]![0]).withContext(`src3.rel8ns.${testRel8nName}[0]`).toEqual('b^gib');
+                iReckon(sir, (src3?.rel8ns![testRel8nName] || []).length).asTo(`src3.rel8ns.${testRel8nName}.length`).isGonnaBe(1);
+                iReckon(sir, src3?.rel8ns![testRel8nName]![0]).asTo(`src3.rel8ns.${testRel8nName}[0]`).isGonnaBe('b^gib');
 
             });
 
-            it(`should rel8 tjp ASAP, i.e. first rel8 after fork, also shoehorned tjpGib testing`, async () => {
+            await ifWe(sir, `should rel8 tjp ASAP, i.e. first rel8 after fork, also shoehorned tjpGib testing`, async () => {
                 // the tjp rel8n should be set ASAP because it's very important.
                 // so if the first transform after fork is a rel8, then do it there.
                 const testRel8ns = { irrelevant: ['ib^gib'] };
@@ -345,30 +345,30 @@ describe(`when rel8ing a regular ibgib`, () => {
                     await fork({ src: primitive, tjp: { uuid: true, timestamp: true } });
                 const tjpAddr = getIbGibAddr({ ibGib: tjpIbGib });
                 const tjpAddrGib = getIbAndGib({ ibGibAddr: tjpAddr }).gib;
-                expect(tjpIbGib?.data?.isTjp).withContext('src1.data.isTjp').toBeTruthy();
-                expect(tjpIbGib?.rel8ns?.tjp).withContext('src1.rel8ns.tjp').toBeUndefined();
+                iReckon(sir, tjpIbGib?.data?.isTjp).asTo('src1.data.isTjp').isGonnaBeTruthy();
+                iReckon(sir, tjpIbGib?.rel8ns?.tjp).asTo('src1.rel8ns.tjp').toBeUndefined();
                 const { newIbGib: hasRel8dTjp } =
                     await rel8({ src: tjpIbGib, rel8nsToAddByAddr: testRel8ns });
                 const hasRel8dTjpAddr = getIbGibAddr({ ibGib: hasRel8dTjp });
                 const hasRel8dTjpAddrGib = getIbAndGib({ ibGibAddr: hasRel8dTjpAddr }).gib;
-                expect(hasRel8dTjp?.data?.isTjp).withContext('src2.data.isTjp').toBeUndefined();
-                expect(hasRel8dTjp?.rel8ns?.tjp).withContext('src2.rel8ns.tjp').toBeTruthy();
-                expect(hasRel8dTjp!.rel8ns!.tjp!.length).withContext('src2.rel8ns.tjp.length').toEqual(1);
-                expect(hasRel8dTjp!.rel8ns!.tjp!).toContain(tjpAddr);
+                iReckon(sir, hasRel8dTjp?.data?.isTjp).asTo('src2.data.isTjp').toBeUndefined();
+                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);
 
                 // the gib should not just be the hash, since it has a tjp timeline
-                expect(hasRel8dTjpAddrGib).toContain(tjpAddrGib);
+                iReckon(sir, hasRel8dTjpAddrGib).toContain(tjpAddrGib);
 
                 // shoe-horning in here some getGibInfo testing...eesh
                 const hasRel8dTjpGibInfo = getGibInfo({ ibGibAddr: hasRel8dTjpAddr }); // via addr
-                expect(hasRel8dTjpGibInfo.isPrimitive).toBeUndefined();
-                expect(hasRel8dTjpGibInfo.piecesCount).toEqual(2, 'pieces count');
+                iReckon(sir, hasRel8dTjpGibInfo.isPrimitive).toBeUndefined();
+                iReckon(sir, hasRel8dTjpGibInfo.piecesCount).isGonnaBe(2, 'pieces count');
                 const hasRel8dTjpHash = await sha256v1(hasRel8dTjp, '');
-                expect(hasRel8dTjpGibInfo.punctiliarHash).toEqual(hasRel8dTjpHash, 'punctiliarHash');
-                expect(hasRel8dTjpGibInfo.tjpGib).toEqual(tjpAddrGib);
+                iReckon(sir, hasRel8dTjpGibInfo.punctiliarHash).isGonnaBe(hasRel8dTjpHash, 'punctiliarHash');
+                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
-                expect(hasRel8dTjpGibInfo_viaGib).toEqual(hasRel8dTjpGibInfo, 'infos via addr and gib should be equal');
+                iReckon(sir, hasRel8dTjpGibInfo_viaGib).isGonnaBe(hasRel8dTjpGibInfo, 'infos via addr and gib should be equal');
 
                 // 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.
@@ -378,22 +378,22 @@ describe(`when rel8ing a regular ibgib`, () => {
                 const thirdGenAddr = getIbGibAddr({ ibGib: thirdGenIbGib });
                 const thirdGenGibInfo = getGibInfo({ ibGibAddr: thirdGenAddr });
                 const thirdGenHash = await sha256v1(thirdGenIbGib, '');
-                expect(thirdGenGibInfo.punctiliarHash).toEqual(thirdGenHash);
-                expect(thirdGenGibInfo.tjpGib).toEqual(tjpAddrGib, 'third gen match tjpAddrGib');
-                expect(thirdGenGibInfo.piecesCount).toEqual(2, 'third gen pieces');
+                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');
             });
         }
     });
 
-    describe(`nCounter`, () => {
-        it(`should increment existing n counter`, async () => {
+    await respecfully(sir, `nCounter`, async () => {
+        await ifWe(sir, `should increment existing n counter`, async () => {
             for (const primitive of PRIMITIVE_IBGIBS) {
                 let { newIbGib: src_0 } =
                     await fork({ src: primitive, nCounter: true });
 
-                expect(src_0.data).toBeTruthy();
-                expect(src_0.data!.n).toEqual(0);
-                expect(src_0!.data?.isTjp).withContext("isTjp").toBeUndefined();
+                iReckon(sir, src_0.data).isGonnaBeTruthy();
+                iReckon(sir, src_0.data!.n).isGonnaBe(0);
+                iReckon(sir, src_0!.data?.isTjp).asTo("isTjp").toBeUndefined();
 
                 const rel8nsToAddByAddr = buildRel8nsToAddOrRemoveFromPrimitives(SIMPLE_REL8N_NAMES);
 
@@ -407,35 +407,35 @@ describe(`when rel8ing a regular ibgib`, () => {
                         noTimestamp: true,
                         nCounter: true
                     });
-                expect(src_1).toBeTruthy();
-                expect(src_1.rel8ns).toBeTruthy();
-                expect(src_1.rel8ns).toBeTruthy();
+                iReckon(sir, src_1).isGonnaBeTruthy();
+                iReckon(sir, src_1.rel8ns).isGonnaBeTruthy();
+                iReckon(sir, src_1.rel8ns).isGonnaBeTruthy();
                 const rel8nNames_AddedIbGib = Object.keys(src_1.rel8ns!);
                 SIMPLE_REL8N_NAMES.forEach(simpleRel8nName => {
-                    expect(rel8nNames_AddedIbGib).toContain(simpleRel8nName);
+                    iReckon(sir, rel8nNames_AddedIbGib).toContain(simpleRel8nName);
                     const simpleRel8nAddrs = src_1.rel8ns![simpleRel8nName]!;
-                    expect(simpleRel8nAddrs).not.toHaveSize(0);
+                    iReckon(sir, simpleRel8nAddrs).not.toHaveSize(0);
                     const expectedRel8nAddrs = rel8nsToAddByAddr[simpleRel8nName];
-                    expect(expectedRel8nAddrs).not.toHaveSize(0);
-                    expect(simpleRel8nAddrs).toEqual(expectedRel8nAddrs!);
+                    iReckon(sir, expectedRel8nAddrs).not.toHaveSize(0);
+                    iReckon(sir, simpleRel8nAddrs).isGonnaBe(expectedRel8nAddrs!);
                 });
 
-                expect(src_1.data).toBeTruthy();
-                expect(src_1.data).toBeTruthy();
-                expect(src_1.data!.n).toBeTruthy();
-                expect(src_1.data!.n).toBeTruthy();
-                expect(src_1.data!.n).toEqual(1);
-                expect(src_1!.data?.isTjp).withContext("isTjp").toBeUndefined();
+                iReckon(sir, src_1.data).isGonnaBeTruthy();
+                iReckon(sir, src_1.data).isGonnaBeTruthy();
+                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();
             }
         });
-        it(`should start new n counter, implicit nCounter falsy`, async () => {
+        await ifWe(sir, `should start new n counter, implicit nCounter falsy`, async () => {
             for (const primitive of PRIMITIVE_IBGIBS) {
                 let { newIbGib: src_0 } =
                     await fork({ src: primitive });
 
-                expect(src_0.data).toBeTruthy();
-                expect(src_0.data).toBeTruthy();
-                expect(src_0.data!.n).toBeUndefined();
+                iReckon(sir, src_0.data).isGonnaBeTruthy();
+                iReckon(sir, src_0.data).isGonnaBeTruthy();
+                iReckon(sir, src_0.data!.n).toBeUndefined();
 
                 const rel8nsToAddByAddr = buildRel8nsToAddOrRemoveFromPrimitives(SIMPLE_REL8N_NAMES);
 
@@ -449,32 +449,32 @@ describe(`when rel8ing a regular ibgib`, () => {
                         noTimestamp: true,
                         nCounter: true
                     });
-                expect(src_1).toBeTruthy();
-                expect(src_1.rel8ns).toBeTruthy();
-                expect(src_1.rel8ns).toBeTruthy();
+                iReckon(sir, src_1).isGonnaBeTruthy();
+                iReckon(sir, src_1.rel8ns).isGonnaBeTruthy();
+                iReckon(sir, src_1.rel8ns).isGonnaBeTruthy();
                 const rel8nNames_AddedIbGib = Object.keys(src_1.rel8ns!);
                 SIMPLE_REL8N_NAMES.forEach(simpleRel8nName => {
-                    expect(rel8nNames_AddedIbGib).toContain(simpleRel8nName);
+                    iReckon(sir, rel8nNames_AddedIbGib).toContain(simpleRel8nName);
                     const simpleRel8nAddrs = src_1.rel8ns![simpleRel8nName]!;
-                    expect(simpleRel8nAddrs).not.toHaveSize(0);
+                    iReckon(sir, simpleRel8nAddrs).not.toHaveSize(0);
                     const expectedRel8nAddrs = rel8nsToAddByAddr[simpleRel8nName];
-                    expect(expectedRel8nAddrs).not.toHaveSize(0);
-                    expect(simpleRel8nAddrs).toEqual(expectedRel8nAddrs!);
+                    iReckon(sir, expectedRel8nAddrs).not.toHaveSize(0);
+                    iReckon(sir, simpleRel8nAddrs).isGonnaBe(expectedRel8nAddrs!);
                 });
 
-                expect(src_1.data).toBeTruthy();
-                expect(src_1.data!.n).toEqual(0);
+                iReckon(sir, src_1.data).isGonnaBeTruthy();
+                iReckon(sir, src_1.data!.n).isGonnaBe(0);
             }
         });
-        it(`should start new n counter, explicit nCounter falsy`, async () => {
+        await ifWe(sir, `should start new n counter, explicit nCounter falsy`, async () => {
             for (const primitive of PRIMITIVE_IBGIBS) {
                 let { newIbGib: src_0 } =
                     await fork({ src: primitive, nCounter: false });
 
-                expect(src_0.data).toBeTruthy();
-                expect(src_0.data).toBeTruthy();
-                expect(src_0.data!.n).toBeUndefined();
-                expect(src_0!.data!.isTjp).withContext("isTjp").toBeUndefined();
+                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();
 
                 const rel8nsToAddByAddr = buildRel8nsToAddOrRemoveFromPrimitives(SIMPLE_REL8N_NAMES);
 
@@ -488,22 +488,22 @@ describe(`when rel8ing a regular ibgib`, () => {
                         noTimestamp: true,
                         nCounter: true
                     });
-                expect(src_1).toBeTruthy();
-                expect(src_1.rel8ns).toBeTruthy();
-                expect(src_1.rel8ns).toBeTruthy();
+                iReckon(sir, src_1).isGonnaBeTruthy();
+                iReckon(sir, src_1.rel8ns).isGonnaBeTruthy();
+                iReckon(sir, src_1.rel8ns).isGonnaBeTruthy();
                 const rel8nNames_AddedIbGib = Object.keys(src_1.rel8ns!);
                 SIMPLE_REL8N_NAMES.forEach(simpleRel8nName => {
-                    expect(rel8nNames_AddedIbGib).toContain(simpleRel8nName);
+                    iReckon(sir, rel8nNames_AddedIbGib).toContain(simpleRel8nName);
                     const simpleRel8nAddrs = src_1.rel8ns![simpleRel8nName]!;
-                    expect(simpleRel8nAddrs).not.toHaveSize(0);
+                    iReckon(sir, simpleRel8nAddrs).not.toHaveSize(0);
                     const expectedRel8nAddrs = rel8nsToAddByAddr[simpleRel8nName];
-                    expect(expectedRel8nAddrs).not.toHaveSize(0);
-                    expect(simpleRel8nAddrs).toEqual(expectedRel8nAddrs!);
+                    iReckon(sir, expectedRel8nAddrs).not.toHaveSize(0);
+                    iReckon(sir, simpleRel8nAddrs).isGonnaBe(expectedRel8nAddrs!);
                 });
 
-                expect(src_1.data).toBeTruthy();
-                expect(src_1.data!.n).toEqual(0);
-                expect(src_1!.data!.isTjp).withContext("isTjp").toBeUndefined();
+                iReckon(sir, src_1.data).isGonnaBeTruthy();
+                iReckon(sir, src_1.data!.n).isGonnaBe(0);
+                iReckon(sir, src_1!.data!.isTjp).asTo("isTjp").toBeUndefined();
             }
         });
         //     for (const primitive of PRIMITIVE_IBGIBS) {
@@ -518,15 +518,15 @@ describe(`when rel8ing a regular ibgib`, () => {
         //                 dataToAddOrPatch: DATA_SIMPLE_XY,
         //                 nCounter: true
         //             });
-        //         expect(src_1.data).toBeTruthy();
-        //         expect(src_1.data!.n).toEqual(0);
+        //         expect(src_1.data).isGonnaBeTruthy();
+        //         expect(src_1.data!.n).isGonnaBe(0);
         //     }
         // });
 
     });
 
-    describe(`when rel8 with dna`, () => {
-        it(`should have gibs that is corroborated with getGib`, async () => {
+    await respecfully(sir, `when rel8 with dna`, async () => {
+        await ifWe(sir, `should have gibs that is corroborated with getGib`, async () => {
             for (const primitive of PRIMITIVE_IBGIBS) {
                 let { newIbGib: src_0 } =
                     await fork({ src: primitive, nCounter: false, dna: true });
@@ -549,7 +549,7 @@ describe(`when rel8ing a regular ibgib`, () => {
                 for (let i = 0; i < ibGibs.length; i++) {
                     const ibGib = ibGibs[i];
                     const gottenGib = await getGib({ ibGib });
-                    expect(ibGib.gib).toEqual(gottenGib);
+                    iReckon(sir, ibGib.gib).isGonnaBe(gottenGib);
                 }
             }
         });

package/src/V1/transforms/transform-helper.spec.mts

@@ -25,21 +25,21 @@ const PRIMITIVE_IBGIBS = [
     }),
 ];
 
-describe(`isDna`, () => {
+await respecfully(sir, `isDna`, async () => {
     for (const src of PRIMITIVE_IBGIBS) {
 
-        it(`should return true for dna ibgibs`, async () => {
+        await ifWe(sir, `should return true for dna ibgibs`, async () => {
             const resFork = await fork({ src, dna: true });
             resFork.dnas?.every(x => {
                 const resIsDna = isDna({ ibGib: x });
-                expect(resIsDna).toBeTrue()
+                iReckon(sir, resIsDna).toBeTrue()
             });
         });
 
-        it(`should return false for non-dna ibgibs`, async () => {
+        await ifWe(sir, `should return false for non-dna ibgibs`, async () => {
             const resFork = await fork({ src, dna: true });
             const resIsDna = isDna({ ibGib: resFork.newIbGib });
-            expect(resIsDna).toBeFalse();
+            iReckon(sir, resIsDna).toBeFalse();
         });
 
     }

package/src/helper.respec.mts

@@ -0,0 +1,62 @@
+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 { Ib, IbGib } from './types.mjs';
+import { ROOT, ROOT_ADDR } from './V1/constants.mjs';
+
+
+await respecfully(sir, `getIbGibAddr`, async () => {
+    // unsure if these would change when not in V1...(these tests are outside V1 atow)
+
+    await ifWe(sir, `should get the right addr for ROOT`, async () => {
+        let ibGib = ROOT;
+        let gotten = getIbGibAddr({ ibGib });
+        iReckon(sir, gotten).isGonnaBeTruthy();
+        iReckon(sir, gotten).isGonnaBe(ROOT_ADDR);
+    });
+
+    await ifWe(sir, `should get the right addr for primitives`, async () => {
+        let ibs: Ib[] = ['7', 'foo', 'ibgib', 'wakka doodle'];
+        for (let i = 0; i < ibs.length; i++) {
+            const ib = ibs[i];
+            let ibGib: IbGib = { ib, gib: 'gib' };
+            let gotten = getIbGibAddr({ ibGib });
+            iReckon(sir, gotten).isGonnaBeTruthy();
+            iReckon(sir, gotten).isGonnaBe(`${ib}^gib`);
+        }
+    });
+
+});
+
+await respecfully(sir, `getIbAndGib`, async () => {
+    // unsure if these would change when not in V1...(these tests are outside V1 atow)
+
+    await ifWe(sir, `should get the right ib & gib for ROOT, with ibGib param`, async () => {
+        let ibGib = ROOT;
+        let gotten = getIbAndGib({ ibGib });
+        iReckon(sir, gotten).isGonnaBeTruthy();
+        iReckon(sir, gotten.ib).isGonnaBe('ib');
+        iReckon(sir, gotten.gib).isGonnaBe('gib');
+    });
+
+    await ifWe(sir, `should get the right ib & gib for ROOT_ADDR, with ibGibAddr param`, async () => {
+        let gotten = getIbAndGib({ ibGibAddr: ROOT_ADDR });
+        iReckon(sir, gotten).isGonnaBeTruthy();
+        iReckon(sir, gotten.ib).isGonnaBe('ib');
+        iReckon(sir, gotten.gib).isGonnaBe('gib');
+    });
+
+    await ifWe(sir, `should get the right ib & gib for primitives`, async () => {
+        let ibs: Ib[] = ['7', 'foo', 'ibgib', 'wakka doodle'];
+        for (let i = 0; i < ibs.length; i++) {
+            const ib = ibs[i];
+            let ibGib: IbGib = { ib, gib: 'gib' };
+            let gotten = getIbAndGib({ ibGib });
+            iReckon(sir, gotten).isGonnaBeTruthy();
+            iReckon(sir, gotten.ib).isGonnaBe(ib);
+            iReckon(sir, gotten.gib).isGonnaBe('gib');
+        }
+    });
+
+});