@ibgib/ts-gib 0.5.1 → 0.5.2

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

@@ -43,58 +43,58 @@ const DATAS_SIMPLE = [
     DATA_SIMPLE_XY_STR,
 ];
 
-describe(`can't mut8 primitives (including the root)`, () => {
+await respecfully(sir, `can't mut8 primitives (including the root)`, async () => {
     for (const src of PRIMITIVE_IBGIBS) {
 
-        it(`should fail to mut8 ib (ib: ${src.ib})`, async () => {
+        await ifWe(sir, `should fail to mut8 ib (ib: ${src.ib})`, async () => {
             let errored = false;
             try {
                 const _ignored = await mut8({ src, mut8Ib: 'changed ' + src.ib });
             } catch (error) {
                 errored = true;
             }
-            expect(errored).toBeTrue()
+            iReckon(sir, errored).toBeTrue()
         });
 
-        it(`should fail to mut8 add or patch data (ib: ${src.ib})`, async () => {
+        await ifWe(sir, `should fail to mut8 add or patch data (ib: ${src.ib})`, async () => {
             let errored = false;
             try {
                 const _ignored = await mut8({ src, dataToAddOrPatch: { a: "aaaaa" } });
             } catch (error) {
                 errored = true;
             }
-            expect(errored).toBeTrue()
+            iReckon(sir, errored).toBeTrue()
         });
 
-        it(`should fail to mut8 rename data (ib: ${src.ib})`, async () => {
+        await ifWe(sir, `should fail to mut8 rename data (ib: ${src.ib})`, async () => {
             let errored = false;
             try {
                 const _ignored = await mut8({ src, dataToRename: { a: "aaaaa" } });
             } catch (error) {
                 errored = true;
             }
-            expect(errored).toBeTrue()
+            iReckon(sir, errored).toBeTrue()
         });
 
-        it(`should fail to mut8 remove data (ib: ${src.ib})`, async () => {
+        await ifWe(sir, `should fail to mut8 remove data (ib: ${src.ib})`, async () => {
             let errored = false;
             try {
                 const _ignored = await mut8({ src, dataToRemove: { a: "aaaaa" } });
             } catch (error) {
                 errored = true;
             }
-            expect(errored).toBeTrue()
+            iReckon(sir, errored).toBeTrue()
         });
     }
 });
 
-describe(`when mutating a regular ibgib`, () => {
+await respecfully(sir, `when mutating a regular ibgib`, async () => {
 
-    describe(`with simple, 1-level, non-nested data and ib`, () => {
+    await respecfully(sir, `with simple, 1-level, non-nested data and ib`, async () => {
         for (const primitive of PRIMITIVE_IBGIBS) {
             for (const testData of DATAS_SIMPLE) {
                 // console.log(`doing testdata: ${primitive.ib}.data ~ ${pretty(testData)}`);
-                it(`should add/rename/patch simple data (${primitive.ib}) and ib`, async () => {
+                await ifWe(sir, `should add/rename/patch simple data (${primitive.ib}) and ib`, async () => {
 
                     let { newIbGib: src } = await fork({ src: primitive, noTimestamp: true });
 
@@ -110,15 +110,15 @@ describe(`when mutating a regular ibgib`, () => {
                         linkedRel8ns: ['past'],
                     });
                     let dataAddedAddr: IbGibAddr = getIbGibAddr({ ibGib: dataAddedIbGib });
-                    expect(dataAddedIbGib).toBeTruthy();
-                    expect(dataAddedIbGib.data).toBeTruthy();
-                    expect(dataAddedIbGib.data).toBeTruthy();
-                    expect(dataAddedIbGib.data).toEqual(testData);
-                    expect(dataAddedIbGib.rel8ns).toBeTruthy();
-                    expect(dataAddedIbGib.rel8ns!.past).toBeTruthy();
-                    expect((dataAddedIbGib.rel8ns!.past || []).length)
-                        .withContext('(dataAddedIbGib.rel8ns!.past || []).length')
-                        .toEqual(1);
+                    iReckon(sir, dataAddedIbGib).isGonnaBeTruthy();
+                    iReckon(sir, dataAddedIbGib.data).isGonnaBeTruthy();
+                    iReckon(sir, dataAddedIbGib.data).isGonnaBeTruthy();
+                    iReckon(sir, dataAddedIbGib.data).isGonnaBe(testData);
+                    iReckon(sir, dataAddedIbGib.rel8ns).isGonnaBeTruthy();
+                    iReckon(sir, dataAddedIbGib.rel8ns!.past).isGonnaBeTruthy();
+                    iReckon(sir, (dataAddedIbGib.rel8ns!.past || []).length)
+                        .asTo('(dataAddedIbGib.rel8ns!.past || []).length')
+                        .isGonnaBe(1);
 
                     // #endregion
 
@@ -135,23 +135,23 @@ describe(`when mutating a regular ibgib`, () => {
                             noTimestamp: true,
                             linkedRel8ns: ['past'],
                         });
-                    expect(dataRenamedIbGib).toBeTruthy();
-                    expect(dataRenamedIbGib.data).toBeTruthy();
-                    expect(dataRenamedIbGib.data).toBeTruthy();
-                    expect(dataRenamedIbGib.rel8ns).toBeTruthy();
-                    expect(dataRenamedIbGib.rel8ns!.past).toBeTruthy();
-                    expect((dataRenamedIbGib.rel8ns!.past || []).length)
-                        .withContext('dataRenamedIbGib.rel8ns!.past || []).length')
-                        .toEqual(1);
+                    iReckon(sir, dataRenamedIbGib).isGonnaBeTruthy();
+                    iReckon(sir, dataRenamedIbGib.data).isGonnaBeTruthy();
+                    iReckon(sir, dataRenamedIbGib.data).isGonnaBeTruthy();
+                    iReckon(sir, dataRenamedIbGib.rel8ns).isGonnaBeTruthy();
+                    iReckon(sir, dataRenamedIbGib.rel8ns!.past).isGonnaBeTruthy();
+                    iReckon(sir, (dataRenamedIbGib.rel8ns!.past || []).length)
+                        .asTo('dataRenamedIbGib.rel8ns!.past || []).length')
+                        .isGonnaBe(1);
 
                     // the data should have the new key name that we did
-                    expect(Object.keys(dataRenamedIbGib.data!)).toContain(newNameForX);
+                    iReckon(sir, Object.keys(dataRenamedIbGib.data!)).toContain(newNameForX);
 
                     // the data value for that new key name should be the same as before, since we didn't change it
-                    expect(dataRenamedIbGib.data![newNameForX]).toEqual(valueForX);
+                    iReckon(sir, dataRenamedIbGib.data![newNameForX]).isGonnaBe(valueForX);
 
                     // the most recent past of the dataRenamed ibGib should be the src's (dataAddedIbGib) address
-                    expect(dataRenamedIbGib.rel8ns!.past![dataRenamedIbGib.rel8ns!.past!.length - 1]).toEqual(dataAddedAddr);
+                    iReckon(sir, dataRenamedIbGib.rel8ns!.past![dataRenamedIbGib.rel8ns!.past!.length - 1]).isGonnaBe(dataAddedAddr);
 
                     //#endregion
 
@@ -162,15 +162,15 @@ describe(`when mutating a regular ibgib`, () => {
 
                     let { newIbGib: dataPatchedIbGib } =
                         await mut8({ src: dataAddedIbGib, dataToAddOrPatch: dataToPatch, noTimestamp: true });
-                    expect(dataPatchedIbGib).toBeTruthy();
-                    expect(dataPatchedIbGib.data).toBeTruthy();
-                    expect(dataPatchedIbGib.data).toBeTruthy();
+                    iReckon(sir, dataPatchedIbGib).isGonnaBeTruthy();
+                    iReckon(sir, dataPatchedIbGib.data).isGonnaBeTruthy();
+                    iReckon(sir, dataPatchedIbGib.data).isGonnaBeTruthy();
 
                     // value should be changed to the new value
-                    expect(dataPatchedIbGib.data!.x).toEqual(newValueForX);
+                    iReckon(sir, dataPatchedIbGib.data!.x).isGonnaBe(newValueForX);
 
                     // the most recent past of the dataRenamed ibGib should be the src's (dataAddedIbGib) address
-                    expect(dataPatchedIbGib.rel8ns!.past![dataPatchedIbGib.rel8ns!.past!.length - 1]).toEqual(dataAddedAddr);
+                    iReckon(sir, dataPatchedIbGib.rel8ns!.past![dataPatchedIbGib.rel8ns!.past!.length - 1]).isGonnaBe(dataAddedAddr);
 
                     //#endregion
 
@@ -180,15 +180,15 @@ describe(`when mutating a regular ibgib`, () => {
 
                     let { newIbGib: dataRemovedIbGib } =
                         await mut8({ src: dataAddedIbGib, dataToRemove, noTimestamp: true });
-                    expect(dataRemovedIbGib).toBeTruthy();
-                    expect(dataRemovedIbGib.data).toBeTruthy();
-                    expect(dataRemovedIbGib.data).toBeTruthy();
+                    iReckon(sir, dataRemovedIbGib).isGonnaBeTruthy();
+                    iReckon(sir, dataRemovedIbGib.data).isGonnaBeTruthy();
+                    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
-                    expect(dataRemovedIbGib.data!.x).toBeUndefined();
+                    iReckon(sir, dataRemovedIbGib.data!.x).toBeUndefined();
 
                     // the most recent past of the dataRemovedIbGib should be the src's address
-                    expect(dataRemovedIbGib.rel8ns!.past![dataRemovedIbGib.rel8ns!.past!.length - 1]).toEqual(dataAddedAddr);
+                    iReckon(sir, dataRemovedIbGib.rel8ns!.past![dataRemovedIbGib.rel8ns!.past!.length - 1]).isGonnaBe(dataAddedAddr);
 
                     //#endregion
 
@@ -196,14 +196,14 @@ describe(`when mutating a regular ibgib`, () => {
 
                     let { newIbGib: ibMut8dIbGib } =
                         await mut8({ src: dataAddedIbGib, mut8Ib: NEW_IB, noTimestamp: true });
-                    expect(ibMut8dIbGib).toBeTruthy();
-                    expect(ibMut8dIbGib.ib).toEqual(NEW_IB);
+                    iReckon(sir, ibMut8dIbGib).isGonnaBeTruthy();
+                    iReckon(sir, ibMut8dIbGib.ib).isGonnaBe(NEW_IB);
 
                     //#endregion
                 });
 
 
-                it(`should be rel8d next mut8`, async () => {
+                await ifWe(sir, `should be rel8d next mut8`, async () => {
                     const { newIbGib: tjpIbGib } = await fork({
                         src: primitive,
                         destIb: 'some ib yo',
@@ -211,40 +211,40 @@ describe(`when mutating a regular ibgib`, () => {
                     });
                     const tjpAddr = getIbGibAddr({ ibGib: tjpIbGib });
                     const tjpAddrGib = getIbAndGib({ ibGibAddr: tjpAddr }).gib;
-                    expect(tjpIbGib!.data?.uuid).toBeTruthy();
-                    expect(tjpIbGib!.data?.isTjp).withContext("isTjp").toBeTrue()
+                    iReckon(sir, tjpIbGib!.data?.uuid).isGonnaBeTruthy();
+                    iReckon(sir, tjpIbGib!.data?.isTjp).asTo("isTjp").toBeTrue()
                     const { newIbGib: hasRel8dTjp } = await mut8({
                         src: tjpIbGib,
                         dataToAddOrPatch: { someData: "not intrinsically pertinent to this test" },
                     });
                     const hasRel8dTjpAddr = getIbGibAddr({ ibGib: hasRel8dTjp });
                     const hasRel8dTjpAddrGib = getIbAndGib({ ibGibAddr: hasRel8dTjpAddr }).gib;
-                    expect(hasRel8dTjp!.data?.uuid).toBeTruthy();
-                    expect(hasRel8dTjp!.data?.isTjp).withContext("isTjp after additional mut8").toBeUndefined();
-                    expect(hasRel8dTjp!.rel8ns).withContext("rel8ns").toBeTruthy();
-                    expect(hasRel8dTjp!.rel8ns!.tjp).withContext("rel8ns.tjp").toBeTruthy();
-                    expect(hasRel8dTjp!.rel8ns!.tjp!.length).withContext("rel8ns.tjp.length").toEqual(1);
-                    expect(hasRel8dTjp!.rel8ns!.tjp).withContext("rel8ns.tjp include").toContain(tjpAddr);
+                    iReckon(sir, hasRel8dTjp!.data?.uuid).isGonnaBeTruthy();
+                    iReckon(sir, hasRel8dTjp!.data?.isTjp).asTo("isTjp after additional mut8").toBeUndefined();
+                    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);
 
                     // 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
                     let 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');
                 });
             }
         } // double for..of statement
     })
 
-    describe(`...and creating dna`, () => {
+    await respecfully(sir, `...and creating dna`, async () => {
         var src: IbGib_V1, forkDnas: IbGib_V1[],
             // these are used later when reapplying dnas to test pure functionality
             addDna: IbGib_V1, dataAddedIbGib1: IbGib_V1,
@@ -257,7 +257,7 @@ describe(`when mutating a regular ibgib`, () => {
             forkDnas = resInit.dnas!;
         })
 
-        it(`should have well-formed dna...`, async () => {
+        await ifWe(sir, `should have well-formed dna...`, async () => {
 
             // #region data added
 
@@ -271,25 +271,25 @@ describe(`when mutating a regular ibgib`, () => {
             let mut8Dna = Mut8AddDnas![0];
             addDna = mut8Dna;
 
-            expect(mut8Dna.ib).withContext(`ib should be mut8`).toEqual('mut8');
+            iReckon(sir, mut8Dna.ib).asTo(`ib should be mut8`).isGonnaBe('mut8');
 
             {
-                expect(mut8Dna?.rel8ns).withContext(`should descend from mut8^gib primitive`).toBeTruthy();
+                iReckon(sir, mut8Dna?.rel8ns).asTo(`should descend from mut8^gib primitive`).isGonnaBeTruthy();
                 const mut8DnaRel8ns: IbGibRel8ns_V1 = mut8Dna?.rel8ns!;
-                expect(mut8DnaRel8ns.ancestor).withContext(`should descend from mut8^gib primitive`).toBeTruthy();
-                expect(mut8DnaRel8ns.ancestor!.length).withContext(`should descend from mut8^gib primitive`).toEqual(1);
-                expect(mut8DnaRel8ns.ancestor![0]).withContext(`should descend from mut8^gib primitive`).toEqual('mut8^gib');
+                iReckon(sir, mut8DnaRel8ns.ancestor).asTo(`should descend from mut8^gib primitive`).isGonnaBeTruthy();
+                iReckon(sir, mut8DnaRel8ns.ancestor!.length).asTo(`should descend from mut8^gib primitive`).isGonnaBe(1);
+                iReckon(sir, mut8DnaRel8ns.ancestor![0]).asTo(`should descend from mut8^gib primitive`).isGonnaBe('mut8^gib');
 
                 const mut8DnaData = (mut8Dna.data as TransformOpts_Mut8<IbGib_V1>)!;
 
-                expect(mut8DnaData).withContext(`should have well-formed common transform opts`).toBeTruthy();
-                expect(mut8DnaData).withContext(`should have well-formed common transform opts`).toBeTruthy();
-                expect(mut8DnaData.dna).withContext(`should have well-formed common transform opts`).toBeTrue()
-                expect(mut8DnaData.srcAddr).withContext(`should have well-formed common transform opts`).toBeUndefined();
-                expect(mut8DnaData.src).withContext(`should have well-formed common transform opts`).toBeUndefined();
+                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();
 
-                expect(mut8DnaData.type).withContext(`should have well-formed data specific to type of mut8`).toEqual("mut8");
-                expect(mut8DnaData.dataToAddOrPatch).withContext(`should have well-formed data specific to type of mut8`).toEqual(dataToAdd);
+                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);
             }
             // #endregion
 
@@ -304,22 +304,22 @@ describe(`when mutating a regular ibgib`, () => {
                 mut8Dna = patchedDnas![0];
                 patchDna = mut8Dna;
 
-                expect(mut8Dna.ib).withContext(`data patched, ib should be mut8`).toEqual('mut8');
-                expect(mut8Dna?.rel8ns).withContext(`data patched, should descend from mut8^gib primitive`).toBeTruthy();
+                iReckon(sir, mut8Dna.ib).asTo(`data patched, ib should be mut8`).isGonnaBe('mut8');
+                iReckon(sir, mut8Dna?.rel8ns).asTo(`data patched, should descend from mut8^gib primitive`).isGonnaBeTruthy();
                 const mut8DnaRel8ns: IbGibRel8ns_V1 = mut8Dna?.rel8ns!;
-                expect(mut8DnaRel8ns.ancestor).withContext(`data patched, should descend from mut8^gib primitive`).toBeTruthy();
-                expect(mut8DnaRel8ns.ancestor!.length).toEqual(1);
-                expect(mut8DnaRel8ns.ancestor![0]).toEqual('mut8^gib');
+                iReckon(sir, mut8DnaRel8ns.ancestor).asTo(`data patched, should descend from mut8^gib primitive`).isGonnaBeTruthy();
+                iReckon(sir, mut8DnaRel8ns.ancestor!.length).isGonnaBe(1);
+                iReckon(sir, mut8DnaRel8ns.ancestor![0]).isGonnaBe('mut8^gib');
 
                 const mut8DnaData = (mut8Dna.data as TransformOpts_Mut8<IbGib_V1>)!;
 
-                expect(mut8DnaData).withContext(`data patched, should have well-formed common transform opts`).toBeTruthy();
-                expect(mut8DnaData).withContext(`data patched, should have well-formed common transform opts`).toBeTruthy();
-                expect(mut8DnaData.dna).withContext(`data patched, should have well-formed common transform opts`).toBeTrue()
-                expect(mut8DnaData.srcAddr).withContext(`data patched, should have well-formed common transform opts`).toBeUndefined();
-                expect(mut8DnaData.src).withContext(`data patched, should have well-formed common transform opts`).toBeUndefined();
-                expect(mut8DnaData.type).withContext(`data patched, should have well-formed data specific to type of mut8`).toEqual("mut8");
-                expect(mut8DnaData.dataToAddOrPatch).withContext(`data patched, should have well-formed data specific to type of mut8`).toEqual(dataToPatch);
+                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.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);
             }
             // #endregion
 
@@ -333,23 +333,23 @@ describe(`when mutating a regular ibgib`, () => {
                 mut8Dna = renamedDnas![0];
                 renameDna = mut8Dna;
 
-                expect(mut8Dna.ib).withContext(`data renamed, ib should be mut8`).toEqual('mut8');
-                expect(mut8Dna?.rel8ns).withContext(`data renamed, should descend from mut8^gib primitive`).toBeTruthy();
+                iReckon(sir, mut8Dna.ib).asTo(`data renamed, ib should be mut8`).isGonnaBe('mut8');
+                iReckon(sir, mut8Dna?.rel8ns).asTo(`data renamed, should descend from mut8^gib primitive`).isGonnaBeTruthy();
                 const mut8DnaRel8ns: IbGibRel8ns_V1 = mut8Dna?.rel8ns!;
-                expect(mut8DnaRel8ns.ancestor).withContext(`data renamed, should descend from mut8^gib primitive`).toBeTruthy();
-                expect(mut8DnaRel8ns.ancestor!.length).withContext(`data renamed, should descend from mut8^gib primitive`).toEqual(1);
-                expect(mut8DnaRel8ns.ancestor![0]).withContext(`data renamed, should descend from mut8^gib primitive`).toEqual('mut8^gib');
+                iReckon(sir, mut8DnaRel8ns.ancestor).asTo(`data renamed, should descend from mut8^gib primitive`).isGonnaBeTruthy();
+                iReckon(sir, mut8DnaRel8ns.ancestor!.length).asTo(`data renamed, should descend from mut8^gib primitive`).isGonnaBe(1);
+                iReckon(sir, mut8DnaRel8ns.ancestor![0]).asTo(`data renamed, should descend from mut8^gib primitive`).isGonnaBe('mut8^gib');
 
                 const mut8DnaData = (mut8Dna.data as TransformOpts_Mut8<IbGib_V1>)!;
 
-                expect(mut8DnaData).withContext(`data renamed, should have well-formed common transform opts`).toBeTruthy();
-                expect(mut8DnaData).withContext(`data renamed, should have well-formed common transform opts`).toBeTruthy();
-                expect(mut8DnaData.dna).withContext(`data renamed, should have well-formed common transform opts`).toBeTrue()
-                expect(mut8DnaData.srcAddr).withContext(`data renamed, should have well-formed common transform opts`).toBeUndefined();
-                expect(mut8DnaData.src).withContext(`data renamed, should have well-formed common transform opts`).toBeUndefined();
+                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();
 
-                expect(mut8DnaData.type).withContext(`data renamed, should have well-formed data specific to type of mut8`).toEqual("mut8");
-                expect(mut8DnaData.dataToRename).withContext(`data renamed, should have well-formed data specific to type of mut8`).toEqual(dataToRename);
+                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);
             }
             // #endregion
 
@@ -364,23 +364,23 @@ describe(`when mutating a regular ibgib`, () => {
                 mut8Dna = removedDnas![0];
                 removeDna = mut8Dna;
 
-                expect(mut8Dna.ib).withContext(`data removed, ib should be mut8`).toEqual('mut8');
-                expect(mut8Dna?.rel8ns).withContext(`data removed, should descend from mut8^gib primitive`).toBeTruthy();
+                iReckon(sir, mut8Dna.ib).asTo(`data removed, ib should be mut8`).isGonnaBe('mut8');
+                iReckon(sir, mut8Dna?.rel8ns).asTo(`data removed, should descend from mut8^gib primitive`).isGonnaBeTruthy();
                 const mut8DnaRel8ns: IbGibRel8ns_V1 = mut8Dna?.rel8ns!;
-                expect(mut8DnaRel8ns.ancestor).withContext(`data removed, should descend from mut8^gib primitive`).toBeTruthy();
-                expect(mut8DnaRel8ns.ancestor!.length).withContext(`data removed, should descend from mut8^gib primitive`).toEqual(1);
-                expect(mut8DnaRel8ns.ancestor![0]).withContext(`data removed, should descend from mut8^gib primitive`).toEqual('mut8^gib');
+                iReckon(sir, mut8DnaRel8ns.ancestor).asTo(`data removed, should descend from mut8^gib primitive`).isGonnaBeTruthy();
+                iReckon(sir, mut8DnaRel8ns.ancestor!.length).asTo(`data removed, should descend from mut8^gib primitive`).isGonnaBe(1);
+                iReckon(sir, mut8DnaRel8ns.ancestor![0]).asTo(`data removed, should descend from mut8^gib primitive`).isGonnaBe('mut8^gib');
 
                 const mut8DnaData = (mut8Dna.data as TransformOpts_Mut8<IbGib_V1>)!;
 
-                expect(mut8DnaData).withContext(`data removed, should have well-formed common transform opts`).toBeTruthy();
-                expect(mut8DnaData).withContext(`data removed, should have well-formed common transform opts`).toBeTruthy();
-                expect(mut8DnaData.dna).withContext(`data removed, should have well-formed common transform opts`).toBeTrue()
-                expect(mut8DnaData.srcAddr).withContext(`data removed, should have well-formed common transform opts`).toBeUndefined();
-                expect(mut8DnaData.src).withContext(`data removed, should have well-formed common transform opts`).toBeUndefined();
+                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();
 
-                expect(mut8DnaData.type).withContext(`data removed, should have well-formed data specific to type of mut8`).toEqual("mut8");
-                expect(mut8DnaData.dataToRemove).withContext(`data removed, should have well-formed data specific to type of mut8`).toEqual(dataToRemove);
+                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);
             }
 
             // #endregion
@@ -405,64 +405,64 @@ describe(`when mutating a regular ibgib`, () => {
                 const optsClone: TransformOpts_Mut8<IbGib_V1> = clone(addDna!.data);
                 optsClone.src = src;
                 const { newIbGib: newIbGib2, dnas: dnas2 } = await mut8(optsClone);
-                expect(newIbGib2).withContext(`should be pure add mutation (expect delay)`).toBeTruthy();
-                expect(dnas2).withContext(`should be pure add mutation (expect delay)`).toBeTruthy();
+                iReckon(sir, newIbGib2).asTo(`should be pure add mutation (expect delay)`).isGonnaBeTruthy();
+                iReckon(sir, dnas2).asTo(`should be pure add mutation (expect delay)`).isGonnaBeTruthy();
                 const dna2 = dnas2![0];
 
                 // dna itself should be exactly the same
-                expect(dna2).withContext(`should be pure add mutation (expect delay)`).toEqual(addDna);
+                iReckon(sir, dna2).asTo(`should be pure add mutation (expect delay)`).isGonnaBe(addDna);
 
                 // 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 be pure add mutation (expect delay)`).not.toEqual(dataAddedIbGib1.gib);
+                iReckon(sir, newIbGib2.gib).asTo(`should be pure add mutation (expect delay)`).not.isGonnaBe(dataAddedIbGib1.gib);
             }
             {
                 await delay(500);
                 const optsClone: TransformOpts_Mut8<IbGib_V1> = clone(patchDna!.data);
                 optsClone.src = dataAddedIbGib1;
                 const { newIbGib: newIbGib2, dnas: dnas2 } = await mut8(optsClone);
-                expect(newIbGib2).withContext(`should be pure patch mutation (expect delay)`).toBeTruthy();
-                expect(dnas2).withContext(`should be pure patch mutation (expect delay)`).toBeTruthy();
+                iReckon(sir, newIbGib2).asTo(`should be pure patch mutation (expect delay)`).isGonnaBeTruthy();
+                iReckon(sir, dnas2).asTo(`should be pure patch mutation (expect delay)`).isGonnaBeTruthy();
                 const dna2 = dnas2![0];
 
                 // dna itself should be exactly the same
-                expect(dna2).withContext(`should be pure patch mutation (expect delay)`).toEqual(patchDna);
+                iReckon(sir, dna2).asTo(`should be pure patch mutation (expect delay)`).isGonnaBe(patchDna);
 
                 // 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 be pure patch mutation (expect delay)`).not.toEqual(dataPatchedIbGib1.gib);
+                iReckon(sir, newIbGib2.gib).asTo(`should be pure patch mutation (expect delay)`).not.isGonnaBe(dataPatchedIbGib1.gib);
             }
             {
                 await delay(500);
                 const optsClone: TransformOpts_Mut8<IbGib_V1> = clone(renameDna!.data);
                 optsClone.src = dataAddedIbGib1;
                 const { newIbGib: newIbGib2, dnas: dnas2 } = await mut8(optsClone);
-                expect(newIbGib2).withContext(`should be pure rename mutation (expect delay)`).toBeTruthy();
-                expect(dnas2).withContext(`should be pure rename mutation (expect delay)`).toBeTruthy();
+                iReckon(sir, newIbGib2).asTo(`should be pure rename mutation (expect delay)`).isGonnaBeTruthy();
+                iReckon(sir, dnas2).asTo(`should be pure rename mutation (expect delay)`).isGonnaBeTruthy();
                 const dna2 = dnas2![0];
 
                 // dna itself should be exactly the same
-                expect(dna2).withContext(`should be pure rename mutation (expect delay)`).toEqual(renameDna);
+                iReckon(sir, dna2).asTo(`should be pure rename mutation (expect delay)`).isGonnaBe(renameDna);
 
                 // 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 be pure rename mutation (expect delay)`).not.toEqual(dataRenamedIbGib1.gib);
+                iReckon(sir, newIbGib2.gib).asTo(`should be pure rename mutation (expect delay)`).not.isGonnaBe(dataRenamedIbGib1.gib);
             }
             {
                 await delay(500);
                 const optsClone: TransformOpts_Mut8<IbGib_V1> = clone(removeDna!.data);
                 optsClone.src = dataAddedIbGib1;
                 const { newIbGib: newIbGib2, dnas: dnas2 } = await mut8(optsClone);
-                expect(newIbGib2).withContext(`should be pure remove mutation (expect delay)`).toBeTruthy();
-                expect(dnas2).withContext(`should be pure remove mutation (expect delay)`).toBeTruthy();
+                iReckon(sir, newIbGib2).asTo(`should be pure remove mutation (expect delay)`).isGonnaBeTruthy();
+                iReckon(sir, dnas2).asTo(`should be pure remove mutation (expect delay)`).isGonnaBeTruthy();
                 const dna2 = dnas2![0];
 
                 // dna itself should be exactly the same
-                expect(dna2).withContext(`should be pure remove mutation (expect delay)`).toEqual(removeDna);
+                iReckon(sir, dna2).asTo(`should be pure remove mutation (expect delay)`).isGonnaBe(removeDna);
 
                 // 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 be pure remove mutation (expect delay)`).not.toEqual(dataRemovedIbGib1.gib);
+                iReckon(sir, newIbGib2.gib).asTo(`should be pure remove mutation (expect delay)`).not.isGonnaBe(dataRemovedIbGib1.gib);
             }
 
             // #endregion
@@ -470,9 +470,9 @@ describe(`when mutating a regular ibgib`, () => {
 
     }); // dna
 
-    describe(`with more complex data`, () => {
+    await respecfully(sir, `with more complex data`, async () => {
         for (const primitive of PRIMITIVE_IBGIBS) {
-            it(`should add/rename/patch (${primitive.ib})`, async () => {
+            await ifWe(sir, `should add/rename/patch (${primitive.ib})`, async () => {
 
                 let { newIbGib: src } = await fork({ src: primitive, noTimestamp: true });
 
@@ -487,10 +487,10 @@ describe(`when mutating a regular ibgib`, () => {
                     noTimestamp: true
                 });
                 let dataAddedAddr: IbGibAddr = getIbGibAddr({ ibGib: dataAddedIbGib });
-                expect(dataAddedIbGib).toBeTruthy();
-                expect(dataAddedIbGib.data).toBeTruthy();
-                expect(dataAddedIbGib.data).toBeTruthy();
-                expect(dataAddedIbGib.data).toEqual(DATA_COMPLEX_XY_NESTED);
+                iReckon(sir, dataAddedIbGib).isGonnaBeTruthy();
+                iReckon(sir, dataAddedIbGib.data).isGonnaBeTruthy();
+                iReckon(sir, dataAddedIbGib.data).isGonnaBeTruthy();
+                iReckon(sir, dataAddedIbGib.data).isGonnaBe(DATA_COMPLEX_XY_NESTED);
 
                 // #endregion
 
@@ -505,20 +505,20 @@ describe(`when mutating a regular ibgib`, () => {
                 let { newIbGib: dataRenamedIbGib } =
                     await mut8({ src: dataAddedIbGib, dataToRename, noTimestamp: true });
                 // let dataRenamedAddr: IbGibAddr = getIbGibAddr({ibGib: dataRenamedIbGib});
-                expect(dataRenamedIbGib).toBeTruthy();
-                expect(dataRenamedIbGib.data).toBeTruthy();
-                expect(dataRenamedIbGib.data).toBeTruthy();
+                iReckon(sir, dataRenamedIbGib).isGonnaBeTruthy();
+                iReckon(sir, dataRenamedIbGib.data).isGonnaBeTruthy();
+                iReckon(sir, dataRenamedIbGib.data).isGonnaBeTruthy();
 
                 // the data should have the new key name that we did
-                expect(dataRenamedIbGib.data!.nested1).toBeTruthy();
-                expect(dataRenamedIbGib.data!.nested1![RENAME_ME_KEY]).toBeUndefined();
-                expect(dataRenamedIbGib.data!.nested1![RENAMED_KEY]).toBeTruthy();
+                iReckon(sir, dataRenamedIbGib.data!.nested1).isGonnaBeTruthy();
+                iReckon(sir, dataRenamedIbGib.data!.nested1![RENAME_ME_KEY]).toBeUndefined();
+                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
-                expect(dataRenamedIbGib.data!.nested1![RENAMED_KEY]).toEqual(RENAME_VALUE);
+                iReckon(sir, dataRenamedIbGib.data!.nested1![RENAMED_KEY]).isGonnaBe(RENAME_VALUE);
 
                 // the most recent past of the dataRenamed ibGib should be the src's (dataAddedIbGib) address
-                expect(dataRenamedIbGib.rel8ns!.past![dataRenamedIbGib.rel8ns!.past!.length - 1]).toEqual(dataAddedAddr);
+                iReckon(sir, dataRenamedIbGib.rel8ns!.past![dataRenamedIbGib.rel8ns!.past!.length - 1]).isGonnaBe(dataAddedAddr);
 
                 //#endregion
 
@@ -529,16 +529,16 @@ describe(`when mutating a regular ibgib`, () => {
 
                 let { newIbGib: dataPatchedIbGib } =
                     await mut8({ src: dataAddedIbGib, dataToAddOrPatch: dataToPatch, noTimestamp: true });
-                expect(dataPatchedIbGib).toBeTruthy();
-                expect(dataPatchedIbGib.data).toBeTruthy();
-                expect(dataPatchedIbGib.data).toBeTruthy();
-                expect(dataPatchedIbGib.data!.xyObj).toBeTruthy();
+                iReckon(sir, dataPatchedIbGib).isGonnaBeTruthy();
+                iReckon(sir, dataPatchedIbGib.data).isGonnaBeTruthy();
+                iReckon(sir, dataPatchedIbGib.data).isGonnaBeTruthy();
+                iReckon(sir, dataPatchedIbGib.data!.xyObj).isGonnaBeTruthy();
 
                 // value should be changed to the new value
-                expect(dataPatchedIbGib.data!.xyObj!.x).toEqual(newValueForX);
+                iReckon(sir, dataPatchedIbGib.data!.xyObj!.x).isGonnaBe(newValueForX);
 
                 // the most recent past of the dataRenamed ibGib should be the src's (dataAddedIbGib) address
-                expect(dataPatchedIbGib.rel8ns!.past![dataPatchedIbGib.rel8ns!.past!.length - 1]).toEqual(dataAddedAddr);
+                iReckon(sir, dataPatchedIbGib.rel8ns!.past![dataPatchedIbGib.rel8ns!.past!.length - 1]).isGonnaBe(dataAddedAddr);
 
                 //#endregion
 
@@ -548,31 +548,31 @@ describe(`when mutating a regular ibgib`, () => {
 
                 let { newIbGib: dataRemovedIbGib } =
                     await mut8({ src: dataAddedIbGib, dataToRemove, noTimestamp: true });
-                expect(dataRemovedIbGib).toBeTruthy();
-                expect(dataRemovedIbGib.data).toBeTruthy();
-                expect(dataRemovedIbGib.data).toBeTruthy();
+                iReckon(sir, dataRemovedIbGib).isGonnaBeTruthy();
+                iReckon(sir, dataRemovedIbGib.data).isGonnaBeTruthy();
+                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
-                expect(dataRemovedIbGib.data!.xyObj).toBeTruthy();
-                expect(dataRemovedIbGib.data!.xyObj!.x).toBeUndefined();
+                iReckon(sir, dataRemovedIbGib.data!.xyObj).isGonnaBeTruthy();
+                iReckon(sir, dataRemovedIbGib.data!.xyObj!.x).toBeUndefined();
 
                 // the most recent past of the dataRemovedIbGib should be the src's address
-                expect(dataRemovedIbGib.rel8ns!.past![dataRemovedIbGib.rel8ns!.past!.length - 1]).toEqual(dataAddedAddr);
+                iReckon(sir, dataRemovedIbGib.rel8ns!.past![dataRemovedIbGib.rel8ns!.past!.length - 1]).isGonnaBe(dataAddedAddr);
 
                 //#endregion
             });
         }
     })
 
-    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).toBeTruthy();
-                expect(src_0.data!.n).toEqual(0);
+                iReckon(sir, src_0.data).isGonnaBeTruthy();
+                iReckon(sir, src_0.data).isGonnaBeTruthy();
+                iReckon(sir, src_0.data!.n).isGonnaBe(0);
 
                 let { newIbGib: src_1 } =
                     await mut8({
@@ -580,19 +580,19 @@ describe(`when mutating a regular ibgib`, () => {
                         dataToAddOrPatch: DATA_SIMPLE_XY,
                         nCounter: true
                     });
-                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);
+                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);
             }
         });
-        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, noTimestamp: true });
 
-                expect(src_0.data).toBeUndefined();
+                iReckon(sir, src_0.data).toBeUndefined();
 
                 let { newIbGib: src_1 } =
                     await mut8({
@@ -600,17 +600,17 @@ describe(`when mutating a regular ibgib`, () => {
                         dataToAddOrPatch: DATA_SIMPLE_XY,
                         nCounter: true
                     });
-                expect(src_1.data).toBeTruthy();
-                expect(src_1.data).toBeTruthy();
-                expect(src_1.data!.n).toEqual(0);
+                iReckon(sir, src_1.data).isGonnaBeTruthy();
+                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, noTimestamp: true, nCounter: false });
 
-                expect(src_0.data).toBeUndefined();
+                iReckon(sir, src_0.data).toBeUndefined();
 
                 let { newIbGib: src_1 } =
                     await mut8({
@@ -618,15 +618,15 @@ describe(`when mutating a regular ibgib`, () => {
                         dataToAddOrPatch: DATA_SIMPLE_XY,
                         nCounter: true
                     });
-                expect(src_1.data).toBeTruthy();
-                expect(src_1.data).toBeTruthy();
-                expect(src_1.data!.n).toEqual(0);
+                iReckon(sir, src_1.data).isGonnaBeTruthy();
+                iReckon(sir, src_1.data).isGonnaBeTruthy();
+                iReckon(sir, src_1.data!.n).isGonnaBe(0);
             }
         });
     });
 
-    describe(`when mut8 with dna`, () => {
-        it(`should have gibs that is corroborated with getGib`, async () => {
+    await respecfully(sir, `when mut8 with dna`, async () => {
+        await ifWe(sir, `should have gibs that is corroborated with getGib`, async () => {
             for (const primitive of PRIMITIVE_IBGIBS) {
                 let { newIbGib, intermediateIbGibs, dnas } =
                     await fork({ src: primitive, nCounter: false, dna: true });
@@ -649,7 +649,7 @@ describe(`when mutating 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);
                 }
             }
         });