@ibgib/ts-gib 0.4.9 → 0.5.1

package/src/V1/validate-helper.mts

@@ -0,0 +1,286 @@
+import { Ib, IbGibAddr, } from '../types.mjs';
+import { IbGib_V1, } from './types.mjs';
+import { IBGIB_DELIMITER, GIB, IB, GIB_DELIMITER, } from './constants.mjs';
+import { isPrimitive, getGib, getGibInfo } from './transforms/transform-helper.mjs';
+
+// import { hasTjp, toDto } from './ibgib';
+
+import { hasTjp, toDto } from './v1-helper.mjs';
+import { HEXADECIMAL_HASH_STRING_REGEXP_32, HEXADECIMAL_HASH_STRING_REGEXP_64 } from '@ibgib/helper-gib';
+import { getIbAndGib, getIbGibAddr } from '../helper.mjs';
+
+const logalot = false;
+
+/**
+ * validates the ibGib's address (`ib` and `gib` properties) and recalculates
+ * the `gib` against the `ibGib.gib`.
+ *
+ * this validates not only that the punctiliar gib hash for this ibgib record
+ * hashes to the same value, but it also checks the internal tjp address and
+ * ensures that it is the same tjp gib in the gib field.
+ *
+ * ## notes
+ *
+ * * By checking the tjp gib is the same in the address as in the tjp rel8n, we
+ *   are providing (extremely?) good corroboration that the tjp listed in the
+ *   address is accurate. However, it may still be theoretically possible to
+ *   forge an ibgib that both hashes to the punctiliar hash and matches up this
+ *   tjpAddr.gib. This would be AFAICT quite challenging.
+ */
+export async function validateIbGibIntrinsically({
+    ibGib
+}: {
+    ibGib: IbGib_V1
+}): Promise<string[] | null> {
+    const lc = `[${validateIbGibIntrinsically.name}]`;
+    try {
+        let errors: string[] = [];
+        if (ibGib) {
+            const addr = getIbGibAddr({ ibGib });
+            errors = validateIbGibAddr({ addr }) ?? [];
+
+            if (errors.length > 0) {
+                console.error(`${lc} errors found in addr: ${addr}`);
+                return errors; // <<<< returns early
+            }
+
+            // rest of the function assumes correctly formatted ib and gib
+
+            // if it's a primitive, the caller knows (or should know!) there are no
+            // metadata guarantees.
+            if (isPrimitive({ gib: ibGib.gib })) { return null; }
+
+            // this validates not only that the punctiliar gib hash for this ibgib record
+            // hashes to the same value, but it also checks the internal tjp address and
+            // ensures that it is the same tjp gib.
+            // not necessary the dto here, but I'm sensitive at this point.
+            let gottenGib = await getGib({ ibGib: toDto({ ibGib }), hasTjp: hasTjp({ ibGib }) });
+            if (gottenGib !== ibGib.gib) {
+                if (ibGib.data?.src && ibGib.data.srcAddr && ibGib.ib === 'rel8') {
+                    // this is NOT the place to do this, but I'm plodding through trying to think of how to fix it
+                    // this is what it looks like in data
+                    // {
+                    //     "rel8nsToAddByAddr":{
+                    //         "comment":["comment 11221^F6B9477984D31FEF5FD25297CA39126A64ADDE2C91C1A2D670CCFE3965DEC4C9.847F0E9A1B2738DC167B32AA9B2D7D9B88B76F21848B1F193E994BB21F90DAEE"]
+                    //     },
+                    //     "dna":true,
+                    //     "nCounter":true,
+                    //     "type":"rel8"
+                    // }
+                    delete ibGib.data.src;
+                    delete ibGib.data.srcAddr;
+                    gottenGib = await getGib({ ibGib: toDto({ ibGib }), hasTjp: hasTjp({ ibGib }) });
+                    if (gottenGib !== ibGib.gib) {
+                        errors.push(`Ibgib invalid intrinsically - gottenGib (${gottenGib}) does not equal ibGib.gib (${ibGib.gib}). (E: 020b71479e944b2198fe436e7e137786)`);
+                        // } else {
+                        //     debugger;
+                    }
+                } else {
+                    errors.push(`Ibgib invalid intrinsically - gottenGib (${gottenGib}) does not equal ibGib.gib (${ibGib.gib}). (E: 7416db016878430ca3c5b20697f164ed)`);
+                }
+            }
+
+            return errors.length > 0 ? errors : null;
+        } else {
+            errors.push(`ibGib is itself falsy. (E: 4fb98caf6ed24ef7b35a19cef56e2d7e)`);
+            return errors;
+        }
+
+    } catch (error) {
+        console.error(`${lc} ${error.message}`);
+        throw error;
+    }
+}
+
+/**
+ * Naive synchronous validation for ibgib addresses.
+ *
+ * @returns error string array if validation errors found, else null
+ */
+export function validateIbGibAddr({
+    addr,
+    delimiter,
+    version,
+}: {
+    addr: IbGibAddr,
+    delimiter?: string,
+    version?: string,
+}): string[] | null {
+    const lc = `[${validateIbGibAddr.name}]`;
+    try {
+        let errors: string[] = [];
+        if (version) { console.warn(`${lc} version not implemented yet. Ignoring. (W: 2d19db16ec0c4766b5d35248787671f3)`); }
+
+        // validate as a whole
+        if (!addr) {
+            errors.push(`addr required. (E: e9a54041aa0b41c1bb2324d9d2d42c7f)`);
+            return errors;
+        }
+        delimiter = delimiter || IBGIB_DELIMITER;
+        if (!addr.includes(delimiter)) { errors.push(`No delimiter (${delimiter}) found. (E: 05e28dcb70ff44019edc53ed508bd1e8)`); }
+        if (addr.startsWith(delimiter)) { errors.push(`addr starts with delim. (E: d29f808c5a47452f9bb3ea684694c6eb)`); }
+
+        // validate pieces...
+        const { ib, gib } = getIbAndGib({ ibGibAddr: addr, delimiter });
+
+        // ...ib
+        const resValidateIb = validateIb({ ib, ibGibAddrDelimiter: delimiter, version });
+        if (resValidateIb) { errors = errors.concat(resValidateIb); }
+
+        // ...gib
+        const resValidateGib = validateGib({ gib, ibGibAddrDelimiter: delimiter, version });
+        if (resValidateGib) { errors = errors.concat(resValidateGib); }
+
+        if (errors.length > 0) {
+            if (logalot) { console.log(`${lc} errors.length > 0. errors: ${errors.join('|')} (I: 9c18f993e138f15613e4c6a340d41722)`); }
+        }
+
+        // we're done
+        return errors.length > 0 ? errors : null;
+    } catch (error) {
+        console.error(`${lc} ${error.message}`);
+        throw error;
+    }
+}
+
+/**
+ * Naive validation of ib.
+ *
+ * @returns errors array if found, else null
+ */
+export function validateIb({
+    ib,
+    ibGibAddrDelimiter,
+    version,
+}: {
+    ib: Ib,
+    ibGibAddrDelimiter?: string,
+    version?: string,
+}): string[] | null {
+    const lc = `[${validateIb.name}]`;
+    try {
+        const errors: string[] = [];
+        if (version) { console.warn(`${lc} version not implemented yet. Ignoring. (W: 71228ba4ed994aaa8149910e295ab087)`); }
+
+        if (!ib) {
+            errors.push(`ib required. (E: a76d06c7b9c24db3a731a91dbe46acd5)`);
+            return errors;
+        }
+
+        if (ib === IB) { return null; }
+
+        ibGibAddrDelimiter = ibGibAddrDelimiter || IBGIB_DELIMITER;
+        if (ib.includes(ibGibAddrDelimiter)) { errors.push(`ib contains ibGibAddrDelimiter (${ibGibAddrDelimiter}) (E: 09e61b46c3e84874bc02b6918f1f2c39)`); }
+
+        return errors.length > 0 ? errors : null;
+    } catch (error) {
+        console.error(`${lc} ${error.message}`);
+        throw error;
+    }
+}
+
+/**
+ * validates a `gib` of some ibGib/ibGibAddr.
+ *
+ * @returns array of validation error strings (if any) or null
+ */
+export function validateGib({
+    gib,
+    gibDelimiter,
+    ibGibAddrDelimiter,
+    version,
+}: {
+    /**
+     * gib to validate.
+     *
+     * ## notes
+     *
+     * If the gib has a tjp embedded in it (i.e. the associated ibgib has a
+     * tjp), then this will call validation on that tjpGib recursively.
+     */
+    gib: Ib,
+    /**
+     * This is a delimiter used with tjpGibs.
+     *
+     * atow this is a dot (`'.'`).
+     *
+     * ## notes
+     *
+     * THIS IS NOT THE SAME THING AS THE `ibGibAddrDelimiter`!
+     */
+    gibDelimiter?: string,
+    /**
+     * This is a delimiter used with the entire ibGibAddr.
+     *
+     * atow this is a caret (`'^'`).
+     *
+     * ## notes
+     *
+     * THIS IS NOT THE SAME THING AS THE `gibDelimiter`!
+     */
+    ibGibAddrDelimiter?: string,
+    /**
+     * Ignored atow, but in the future, probably will be used.
+     * May end up being an IbGibAddr but who knows.
+     */
+    version?: string,
+}): string[] | null {
+    const lc = `[${validateGib.name}]`;
+    try {
+        const errors: string[] = [];
+        if (version) { console.warn(`${lc} version not implemented yet. Ignoring. (E: 90ced1db69774702b92acb261bdaee23)`); }
+
+        if (!gib) {
+            errors.push(`gib required. (E: e217de4035b04086827199f4bace189c)`);
+            return errors;
+        }
+
+        ibGibAddrDelimiter = ibGibAddrDelimiter || IBGIB_DELIMITER;
+        /** Need to move this to ts-gib */
+        const INVALID_GIB_CHARS = [ibGibAddrDelimiter];
+        const invalidCharsFound: string[] = [];
+        INVALID_GIB_CHARS.forEach(invalidChar => {
+            if (gib.includes(invalidChar)) { invalidCharsFound.push(invalidChar); }
+        });
+        if (invalidCharsFound.length > 0) {
+            errors.push(`gib (${gib}}) contains invalid characters: (${JSON.stringify(invalidCharsFound.join(','))}) (E: 1e584258d9e049ba9ce7e516f3ab97f1)`);
+        }
+
+        // punctiliar = point, i.e., a single point in the universe, either a
+        // single point in time in a tjp ibgib's timeline, or a single point in
+        // space that lives outside of time (has no tjp thus no timeline).
+        //
+        // So if we've gotten here in code, then our gib is truthy and doesn't
+        // contain invalid characters.
+
+        const { punctiliarHash, tjpGib, isPrimitive } =
+            getGibInfo({ gib, gibDelimiter: gibDelimiter || GIB_DELIMITER });
+
+        // automatically valid if it's a primitive, as the caller should expect
+        // no cryptographical guarantees
+        if (isPrimitive) { return null; }
+
+        // Gib is not primitive so must have at least the punctiliar hash.
+        if (!punctiliarHash) { throw new Error(`${lc} punctiliarHash is falsy on a non-primitive gib. (E: 72835394918241bdb2632bf0510bdae5)`); }
+        const punctiliarHashIs_32 = punctiliarHash!.match(HEXADECIMAL_HASH_STRING_REGEXP_32);
+        const punctiliarHashIs_64 = punctiliarHash!.match(HEXADECIMAL_HASH_STRING_REGEXP_64);
+        if (!punctiliarHashIs_32 && !punctiliarHashIs_64) {
+            errors.push('gib punctiliar hash is neither a 32- or 64-char hash string. (E: d47ff6d6e14b4c02a62107090c8dad39)');
+        }
+
+        if (tjpGib) {
+            // if it is an ibgib in a timeline, that timeline has a tjp and this
+            // gib has a tjpGib component. So we must recursively validate the
+            // tjpGib
+            const tjpGibValidationErrors = validateGib({ gib: tjpGib });
+            if ((tjpGibValidationErrors ?? []).length > 0) {
+                errors.push(`tjpGib has errors (E: d6b79228d4a64c0b967cdb0efcea4d0d). tjpGibValidationErrors: ${tjpGibValidationErrors!.join('. ')}`);
+            }
+        }
+
+        return errors.length > 0 ? errors : null;
+    } catch (error) {
+        console.error(`${lc} ${error.message}`);
+        throw error;
+    }
+}

package/src/helper.mts

@@ -1,19 +1,6 @@
 import { Ib, Gib, IbGib, IbGibAddr, IbAndGib } from './types.mjs';
-let crypto: any = globalThis.crypto;
-let { subtle } = crypto;
 
-export type HashAlgorithm = 'SHA-256' | 'SHA-512';
-export const HashAlgorithm: { [key: string]: HashAlgorithm } = {
-    'sha_256': 'SHA-256' as HashAlgorithm,
-    'sha_512': 'SHA-512' as HashAlgorithm,
-}
 
-export function clone(obj: any) {
-    return JSON.parse(JSON.stringify(obj));
-}
-export function getTimestamp() {
-    return (new Date()).toUTCString();
-}
 /**
  * Gets the ib^gib address from the given ib and gib or
  * from the ibGib object.
@@ -87,106 +74,3 @@ export function getIbAndGib({
         }
     }
 }
-
-/**
- * Simple hash function.
- *
- * NOTE:
- *   This is not used for ibGib.gib values (ATOW)
- *   but rather as a helper function for generating random UUIDs.
- *
- * @param s string to hash
- * @param algorithm to use, currently only 'SHA-256'
- */
-export async function hash({
-    s,
-    algorithm = 'SHA-256',
-}: {
-    s: string,
-    algorithm?: HashAlgorithm,
-}): Promise<string> {
-    if (!s) { return ''; }
-
-    const validAlgorithms = Object.values(HashAlgorithm);
-    if (!validAlgorithms.includes(algorithm)) {
-        console.error(`Only ${validAlgorithms} implemented`); return '';
-    }
-    try {
-        const msgUint8 = new TextEncoder().encode(s);
-        const buffer = await subtle.digest(algorithm, msgUint8);
-        const asArray = Array.from(new Uint8Array(buffer));
-        return asArray.map(b => b.toString(16).padStart(2, '0')).join('');
-    } catch (e) {
-        console.error(extractErrorMsg(e.message));
-        return '';
-    }
-}
-
-/**
- * Simple func to generate UUID (sha-256 hash basically).
- *
- * @param seedSize size of seed for UUID generation
- */
-export async function getUUID(seedSize = 64): Promise<string> {
-    let uuid: string = '';
-    if (seedSize < 32) { throw new Error(`Seed size must be at least 32`); }
-    if (!globalThis.crypto) { throw new Error(`Cannot create UUID, as unknown crypto library version. If using node.js, v19+ is required. (E: c02cee3fd8a94f678d3f4ebe9dc49797)`); }
-
-    const values = crypto.getRandomValues(new Uint8Array(16));
-    uuid = await hash({ s: values.join('') });
-
-    if (!uuid) { throw new Error(`Did not create UUID...hmm...`); }
-
-    return uuid;
-}
-
-/**
- * Syntactic sugar for JSON.stringify(obj, null, 2);
- *
- * @param obj to pretty stringify
- */
-export function pretty(obj: any): string {
-    return JSON.stringify(obj, null, 2);
-}
-
-/**
- * Just delays given number of ms.
- *
- * @param ms milliseconds to delay
- */
-export async function delay(ms: number): Promise<void> {
-    return new Promise<void>(resolve => {
-        setTimeout(() => {
-            resolve();
-        }, ms);
-    });
-}
-
-/**
- * extracts the error message from an error object/string/falsy arg.
- *
- * ## notes
- *
- * * some libs throw errors, some throw just strings.
- * * who knows what else it could be.
- *
- * ## todo
- *
- * * extract inner errors/causes if we ever use this function extensively.
- *
- * @param error the error object in the catch area of the try..catch block.
- * @returns error.message if it's a string, error itself if it's a string, or canned error messages if it's falsy or none of the above.
- */
-export function extractErrorMsg(error: any): string {
-    if (!error && error !== 0) {
-        return '[error is falsy]';
-    } else if (typeof error === 'string') {
-        return error;
-    } else if (typeof error.message === 'string') {
-        return error.message;
-    } else if (typeof error === 'number') {
-        return JSON.stringify(error);
-    } else {
-        return `[error is not a string and error.message is not a string. typeof error: ${typeof error}]`;
-    }
-}

package/src/helper.spec.mts

@@ -1,127 +1,59 @@
-/**
- * Test helper functions.
- */
+import { getIbAndGib, getIbGibAddr } from './helper.mjs';
+import { Ib, IbGib } from './types.mjs';
+import { ROOT, ROOT_ADDR } from './V1/constants.mjs';
 
-import * as h from './helper.mjs';
-import { HashAlgorithm } from './helper.mjs';
 
-const SOME_STRING = "This is some stringy stuff...";
-const SOME_STRING_HASH = "5DC14EA1027B956AD6BA51F11372DF823FCF3429B5F2063F1DDA358E0F4F2992";
-const SOME_STRING_HASH_512 = "C48C780DA7C43EE7047CDAB0D7A2FDF5DC050DF3291D3CAE973FB0F51BE8535668592EB25A730C95A23D3B4D57924893E7E87C86DC0F52C6D5D2E34EE41203E5";
-const SOME_OTHER_STRING = "This is quite a different string of stuff.";
-const TEST_HASHES: { [key: string]: string } = {
-    [SOME_STRING + h.HashAlgorithm.sha_256]: SOME_STRING_HASH,
-    [SOME_STRING + h.HashAlgorithm.sha_512]: SOME_STRING_HASH_512,
-    [SOME_OTHER_STRING + h.HashAlgorithm.sha_256]: 'AE4C18B37B2329770E05EA3F946C6EB6DE56D2DC568E1F5CBB395E2A1556F58A',
-    [SOME_OTHER_STRING + h.HashAlgorithm.sha_512]: '2F1A72B21C914ED459319DF4B5D70E81CEE67C4B48BC74CD6BA8F41DCEC20DCD100C914913F370B2782985268D05C590B46F3FE9005A7477BA952935D2454E53',
-}
+describe(`getIbGibAddr`, () => {
+    // unsure if these would change when not in V1...(these tests are outside V1 atow)
 
-describe(`when cloning`, () => {
-
-    it(`should copy deep objects`, async () => {
-        const objSimple = { a: SOME_STRING };
-        const objADeep = {
-            levelOne: {
-                levelTwo: {
-                    buckle: "your shoe",
-                    three: "four",
-                    objSimple: objSimple,
-                }
-            }
-        };
-        const cloneADeep = h.clone(objADeep);
-        expect(cloneADeep?.levelOne?.levelTwo?.buckle).toBe("your shoe");
-        expect(cloneADeep?.levelOne?.levelTwo?.three).toBe("four");
-        expect(cloneADeep?.levelOne?.levelTwo?.objSimple).toEqual(objSimple);
-
-        cloneADeep.levelOne.levelTwo.objSimple.a = SOME_OTHER_STRING;
-
-        // original should **still** be the first value
-        expect(objSimple.a).toBe(SOME_STRING);
-        // clone should be changed.
-        expect(cloneADeep.levelOne.levelTwo.objSimple.a).toBe(SOME_OTHER_STRING);
-    });
-});
-
-describe(`when getting timestamp`, () => {
-    it(`should get the current date as UTCString`, async () => {
-        // implementation detail hmm....
-        const timestamp = h.getTimestamp();
-        const date = new Date(timestamp);
-        const dateAsUTCString = date.toUTCString();
-        expect(timestamp).toBe(dateAsUTCString);
+    it(`should get the right addr for ROOT`, async () => {
+        let ibGib = ROOT;
+        let gotten = getIbGibAddr({ ibGib });
+        expect(gotten).toBeTruthy();
+        expect(gotten).toEqual(ROOT_ADDR);
     });
-});
-
-describe(`when hashing (helper)`, () => {
-    const TEST_ALGORITHMS: h.HashAlgorithm[] = Object.values(h.HashAlgorithm);
 
-    // implicit is just SHA-256
-    it(`should hash consistently with implicit SHA-256`, async () => {
-        const hash = await h.hash({ s: SOME_STRING }) || "";
-        expect(hash.toUpperCase()).toBe(TEST_HASHES[SOME_STRING + 'SHA-256']);
+    it(`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 });
+            expect(gotten).toBeTruthy();
+            expect(gotten).toEqual(`${ib}^gib`);
+        }
     });
 
-    for (let algorithm of TEST_ALGORITHMS) {
-        it(`should hash consistently with explicit ${algorithm}`, async () => {
-            // const hash = await h.hash({s: SOME_STRING, algorithm: "SHA-256"}) || "";
-            let hash = await h.hash({ s: SOME_STRING, algorithm }) || "";
-            expect(hash.toUpperCase()).toBe(TEST_HASHES[SOME_STRING + algorithm]);
-            hash = await h.hash({ s: SOME_OTHER_STRING, algorithm }) || "";
-            expect(hash.toUpperCase()).toBe(TEST_HASHES[SOME_OTHER_STRING + algorithm]);
-        });
-        it(`should hash without collisions, 1000 times, ${algorithm}`, async () => {
-            const hashes: string[] = [];
-            const salt = await h.getUUID(1024);
-            // console.log(`salt: ${salt}`);
-            for (let i = 0; i < 1000; i++) {
-                const hash = await h.hash({ s: salt + i.toString(), algorithm }) || "";
-                // console.log(hash);
-                expect(hashes).not.toContain(hash);
-                hashes.push(hash);
-            }
-        });
-    };
 });
 
-describe(`when generating UUIDs`, () => {
-    it(`shouldn't duplicate UUIDs`, async () => {
-        const ids: string[] = [];
-        for (let i = 0; i < 100; i++) {
-            const id = await h.getUUID();
-            expect(ids).not.toContain(id);
-            ids.push(id);
+describe(`getIbAndGib`, () => {
+    // unsure if these would change when not in V1...(these tests are outside V1 atow)
+
+    it(`should get the right ib & gib for ROOT, with ibGib param`, async () => {
+        let ibGib = ROOT;
+        let gotten = getIbAndGib({ ibGib });
+        expect(gotten).toBeTruthy();
+        expect(gotten.ib).toEqual('ib');
+        expect(gotten.gib).toEqual('gib');
+    });
+
+    it(`should get the right ib & gib for ROOT_ADDR, with ibGibAddr param`, async () => {
+        let gotten = getIbAndGib({ ibGibAddr: ROOT_ADDR });
+        expect(gotten).toBeTruthy();
+        expect(gotten.ib).toEqual('ib');
+        expect(gotten.gib).toEqual('gib');
+    });
+
+    it(`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 });
+            expect(gotten).toBeTruthy();
+            expect(gotten.ib).toEqual(ib);
+            expect(gotten.gib).toEqual('gib');
         }
     });
-});
 
-describe(`when extractErrorMsg`, () => {
-    it(`should return canned msg when error is falsy`, () => {
-        const defaultMsg = '[error is falsy]'; // duplicate of code in helper.mjs
-        [null, undefined, ''].forEach(error => {
-            expect(h.extractErrorMsg(error)).withContext(JSON.stringify(error)).toEqual(defaultMsg);
-        });
-    });
-    it(`should return incoming error if it is a string`, () => {
-        ['string here', 'undefined', '42', 'ibgib'].forEach(stringError => {
-            expect(h.extractErrorMsg(stringError)).withContext(JSON.stringify(stringError)).toEqual(stringError);
-        });
-    });
-    it(`should return error.message if it's a thrown error`, () => {
-        ['string here', 'undefined', 'something went wrong', 'danger. out of memory (E: ce86ffd7a0174c1d8ce5e56c807dd4b1)']
-            .map(x => new Error(x))
-            .forEach(error => {
-                expect(h.extractErrorMsg(error)).withContext(error.message).toEqual(error.message);
-            });
-    });
-    it(`should return incoming error stringified if it is a number`, () => {
-        [1234, 0, 1_000, Number.MAX_SAFE_INTEGER, Number.MIN_SAFE_INTEGER, -5, 1 / 23].forEach(numberError => {
-            expect(h.extractErrorMsg(numberError)).withContext(JSON.stringify(numberError)).toEqual(JSON.stringify(numberError));
-        });
-    });
-    it(`should return canned response with type if incoming error is none of the above`, () => {
-        let error = { x: 1, y: 2 };
-        let msg = h.extractErrorMsg(error);
-        expect(msg).withContext(JSON.stringify(error)).toBeTruthy();
-    });
-});
+});

package/src/types.mts

@@ -1,17 +1,44 @@
 /**
- * The core of the simplicity of the ibGib protocol is that
- * fundamentally you are taking two ibGibs and producing a third.
+ * @module types
  *
- * There are three primary functions: mut8, rel8, fork
+ * These are the core types at the lowest level of the ibGib protocol.
  *
- * These are actually different aspects of the single function of
- * relationship and time, either extending or creating a timeline.
+ * The core of the simplicity of the ibGib protocol is that fundamentally you
+ * are encompassing the idea of an ibgib (similar to a base class "object" or
+ * "thing") that has intrinsic data and relationships to extrinsic ibgib.  Each
+ * ibgib is content addressed with a unique addressing style called its ib^gib
+ * address. This allows us semantics for abstracting the "content addressing"
+ * per use case, with various schemas allowed, but in general the `ib` is
+ * per-use-case metadata and the `gib` is the more conventional hash of the
+ * ibgib record to allow for the cryptographic guarantees one would expect. Each
+ * discrete frame in time of the ibgib is its own ibgib, and a timeline stream
+ * of that ibgib is created via the "past" relationship (`rel8n`).
  *
- * Mut8 is intrinsic, rel8 is extrinsic, fork is a new timeline.
- * Mut8 changes a timeline, rel8 changes a timeline's link(s),
- * fork creates a new timeline.
+ * New ibgib records are created via "transforms", of which atow there are three
+ * kinds: `mut8`, `rel8`, `fork`
+ *
+ * These are actually different aspects of the single function of relationship
+ * and time, either extending or creating a timeline.
+ *
+ * Mut8 is intrinsic, rel8 is extrinsic, fork makes a new timeline.  Mut8
+ * changes a timeline, rel8 changes a timeline's link(s), fork creates a new
+ * timeline.
+ *
+ * ## notes
+ *
+ * I have attempted to make these version independent, though we will not know
+ * how successful that is until we do a V2.
+ */
+
+/**
+ * Type alias of string (or empty string) that is meant to convey that it
+ * is used as the ib in an ib^gib address or an `IbGib` class.
  */
 export declare type Ib = '' | string;
+/**
+ * Type alias of string (or empty string) that is meant to convey that it
+ * is used as the gib in an ib^gib address or an `IbGib` class.
+ */
 export declare type Gib = '' | 'gib' | string;
 /**
  * Convenient for when destructuring an IbGibAddr
@@ -27,6 +54,11 @@ export interface IbAndGib {
  * that's to decide for future.
  */
 export declare type IbGibAddr = string;
+/**
+ * Type alias that indicates that this is intended to be a tjp (temporal
+ * junction point) address.
+ */
+export declare type TjpIbGibAddr = IbGibAddr;
 export declare type IbGibRel8ns = {
     /**
      * The key is the rel8nName.
@@ -224,7 +256,6 @@ export interface TransformOpts_Rel8<TSrc extends IbGib = IbGib> extends Transfor
      */
     rel8nsToRemoveByAddr?: IbGibRel8ns;
 }
-
 export interface TransformResult<TOut extends IbGib> {
     /**
      * The final result of the transformation

package/dist/index.cjs

@@ -1,4 +0,0 @@
-export * as V1 from './V1/index.mjs';
-export * from './types.mjs';
-export * from './helper.mjs';
-//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.cjs","sourceRoot":"","sources":["../src/index.cts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,gBAAgB,CAAC;AACrC,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC"}

package/dist/index.d.cts

@@ -1,4 +0,0 @@
-export * as V1 from './V1/index.mjs';
-export * from './types.mjs';
-export * from './helper.mjs';
-//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.cts","sourceRoot":"","sources":["../src/index.cts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,gBAAgB,CAAC;AACrC,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC"}

package/src/index.cts

@@ -1,3 +0,0 @@
-export * as V1 from './V1/index.mjs';
-export * from './types.mjs';
-export * from './helper.mjs';