@ibgib/core-gib 0.1.8 → 0.1.10

package/src/test/mock-space.mts

@@ -0,0 +1,85 @@
+import { IbGib_V1 } from '@ibgib/ts-gib/dist/V1/types.mjs';
+import { getIbGibAddr } from '@ibgib/ts-gib/dist/helper.mjs';
+
+/**
+ * A simple in-memory map acting as a Space.
+ * Pure Storage. No Indexing logic.
+ * 
+ * Copied/Adapted from Keystone Respecs.
+ */
+export class MockIbGibSpace {
+    store = new Map<string, IbGib_V1>();
+
+    constructor(public name: string = "mock_space") { }
+
+    async put({ ibGib }: { ibGib: IbGib_V1 }): Promise<void> {
+        const addr = getIbGibAddr({ ibGib });
+        this.store.set(addr, JSON.parse(JSON.stringify(ibGib))); // Deep copy
+    }
+
+    async get({ addr }: { addr: string }): Promise<IbGib_V1 | null> {
+        const data = this.store.get(addr);
+        return data ? JSON.parse(JSON.stringify(data)) : null;
+    }
+
+    async witness(arg: any): Promise<any> {
+        const cmd = arg.data?.cmd;
+        if (cmd === 'get') {
+            const addrs = arg.data.ibGibAddrs || [];
+            const ibGibs: IbGib_V1[] = [];
+            for (const addr of addrs) {
+                const ig = await this.get({ addr });
+                if (ig) ibGibs.push(ig);
+            }
+            return { ibGibs };
+        }
+        if (cmd === 'put') {
+            const ibGibs = arg.ibGibs || [];
+            for (const ibGib of ibGibs) {
+                await this.put({ ibGib });
+            }
+            return { ibGibs: [] }; // Return empty result or whatever witness expects
+        }
+        return undefined;
+    }
+}
+
+/**
+ * A partial mock of Metaspace.
+ */
+export class MockMetaspaceService {
+
+    /**
+     * Map of TJP Gib (Timeline ID) -> Latest IbGib Addr (Head)
+     */
+    timelineHeads = new Map<string, string>();
+
+    constructor(public space: MockIbGibSpace) { }
+
+    async getLocalUserSpace({ lock }: { lock: boolean }): Promise<MockIbGibSpace> {
+        return this.space;
+    }
+
+    async put(args: any): Promise<void> {
+        const target = args.space || this.space;
+        return target.put(args);
+    }
+
+    async registerNewIbGib(args: { ibGib: IbGib_V1, space?: any }): Promise<void> {
+        const { ibGib } = args;
+        const targetSpace = args.space || this.space;
+
+        // 1. Ensure it is stored
+        await targetSpace.put({ ibGib });
+
+        // 2. Extract TJP
+        const gib = ibGib.gib || '';
+        let tjpGib = gib;
+        if (gib.includes('.')) {
+            const parts = gib.split('.');
+            tjpGib = parts.slice(1).join('.');
+        }
+        const addr = getIbGibAddr({ ibGib });
+        this.timelineHeads.set(tjpGib, addr);
+    }
+}

package/src/witness/space/inner-space/inner-space-v1.respec.mts

@@ -5,10 +5,11 @@ import {
 } from '@ibgib/helper-gib/dist/respec-gib/respec-gib.mjs';
 const maam = `[${import.meta.url}]`, sir = maam;
 import { getIbGibAddr } from '@ibgib/ts-gib/dist/helper.mjs';
-// import { IbGib_V1 } from '@ibgib/ts-gib/dist/V1/types.mjs';
-
+import { Factory_V1 } from '@ibgib/ts-gib/dist/V1/factory.mjs';
+import { mut8 } from '@ibgib/ts-gib/dist/V1/transforms/mut8.mjs';
+import { rel8 } from '@ibgib/ts-gib/dist/V1/transforms/rel8.mjs';
+import { fork } from '@ibgib/ts-gib/dist/V1/transforms/fork.mjs';
 import { getTjpAddr } from '../../../common/other/ibgib-helper.mjs';
-// import { SyncSpaceOptionsIbGib } from '../outer-space/outer-space-types.mjs';
 
 import {
     testSpace_createAndInit,
@@ -17,235 +18,187 @@ import {
     testSpace_registerNewIbGib_GetLatest,
 } from '../space-respec-helper.mjs';
 import { InnerSpace_V1, } from './inner-space-v1.mjs';
-import { createTimeline, getHistory, mut8Timeline } from '../../../timeline/timeline-api.mjs';
-import { MetaspaceService } from '../metaspace/metaspace-types.mjs';
-import { Metaspace_Innerspace } from '../metaspace/metaspace-innerspace/metaspace-innerspace.mjs';
-// import { getLatestAddrs, putInSpace } from '../space-helper.mjs';
+import { DEFAULT_INNER_SPACE_DATA_V1 } from './inner-space-types.mjs';
+import { putInSpace, getFromSpace } from '../space-helper.mjs';
 
 const logalot = true;
-/**
- * not sure where to put this, but we probably will want to reuse this in the
- * future (assuming it works)
- * @returns metaspace service reference
- */
-async function getNewInitializedInMemoryMetaspaceForTesting({
-    defaultSpaceName,
-}: {
-    defaultSpaceName: string,
-}): Promise<MetaspaceService> {
-    const lc = `[${getNewInitializedInMemoryMetaspaceForTesting.name}]`;
-    try {
-        if (logalot) { console.log(`${lc} starting... (I: 766d7596addcb73f4820586469233b25)`); }
-
-        let metaspace = new Metaspace_Innerspace(/*cacheSvc*/undefined);
-        if (logalot) { console.log(`${lc} creating metaspace complete. initializing... (I: 61b74d62e8832c9fa853e4b8c4c2d825)`); }
-
-        await metaspace.initialize({
-            spaceName: defaultSpaceName,
-            metaspaceFactory: undefined,
-            getFnAlert: () => { return async ({ title, msg }) => console.log(title, msg) },
-            getFnPrompt: () => {
-                return async ({ title, msg }) => {
-                    // if this is needed, we might set up some way for testing
-                    // to prepare either a queue of prompts or some kind of map
-                    // and put it on the metaspace itself
-                    throw new Error(`not implemented (E: c7ef688a02f8cb74487260f9274ac825)`);
-                    // promptForText({ title, msg, confirm: false });
-                }
-            },
-            getFnPromptPassword: () => {
-                return async () => {
-                    return 'password';
-                    // promptForSecret({ confirm: true })
-                }
-            },
+
+await respecfully(sir, `[${InnerSpace_V1.name} specs]`, async () => {
+
+    await testSpace_createAndInit({
+        respecfulTitle: sir,
+        // shortcircuitRespec: true,
+        fnGetInitialSpaceData: async () => {
+            return {
+                ...DEFAULT_INNER_SPACE_DATA_V1,
+                name: (await getUUID()).substring(0, 8),
+                uuid: await getUUID(),
+            };
+        },
+        fnGetInitialSpaceRel8ns: () => {
+            return Promise.resolve(undefined);
+        },
+        fnGetSpace: (initialData: any, initialRel8ns) => {
+            return Promise.resolve(new InnerSpace_V1(initialData, initialRel8ns));
+        },
+    })
+
+    await testSpace_putGetDelete({
+        respecfulTitle: sir,
+        // shortcircuitRespec: true,
+        fnGetInitialSpaceData: async () => {
+            return {
+                ...DEFAULT_INNER_SPACE_DATA_V1,
+                name: (await getUUID()).substring(0, 8),
+                uuid: await getUUID(),
+            };
+        },
+        fnGetInitialSpaceRel8ns: () => {
+            return Promise.resolve(undefined);
+        },
+        fnGetSpace: (initialData: any, initialRel8ns) => {
+            return Promise.resolve(new InnerSpace_V1(initialData, initialRel8ns));
+        },
+    });
+
+    await testSpace_persistTransformResult({
+        respecfulTitle: sir,
+        // shortcircuitRespec: true,
+        fnGetInitialSpaceData: async () => {
+            return {
+                ...DEFAULT_INNER_SPACE_DATA_V1,
+                name: (await getUUID()).substring(0, 8),
+                uuid: await getUUID(),
+            };
+        },
+        fnGetInitialSpaceRel8ns: () => {
+            return Promise.resolve(undefined);
+        },
+        fnGetSpace: (initialData: any, initialRel8ns) => {
+            return Promise.resolve(new InnerSpace_V1(initialData, initialRel8ns));
+        },
+    });
+
+    await testSpace_registerNewIbGib_GetLatest({
+        respecfulTitle: sir,
+        // shortcircuitRespec: true,
+        fnGetInitialSpaceData: async () => {
+            return {
+                ...DEFAULT_INNER_SPACE_DATA_V1,
+                name: (await getUUID()).substring(0, 8),
+                uuid: await getUUID(),
+            };
+        },
+        fnGetInitialSpaceRel8ns: () => {
+            return Promise.resolve(undefined);
+        },
+        fnGetSpace: (initialData: any, initialRel8ns) => {
+            return Promise.resolve(new InnerSpace_V1(initialData, initialRel8ns));
+        },
+        testLatestIterations: 5,
+    });
+
+    await respecfully(sir, 'Advanced Operations (mut8, rel8, fork)', async () => {
+
+        await ifWe(sir, 'should handle mut8 transform and persistence', async () => {
+            const space = new InnerSpace_V1(DEFAULT_INNER_SPACE_DATA_V1, undefined);
+            const gib = Factory_V1.primitive({ ib: 'gib' });
+
+            // 1. Create Origin
+            const resOrigin = await Factory_V1.firstGen({
+                ib: 'origin',
+                data: { initial: 'data' },
+                dna: true,
+                parentIbGib: gib,
+            });
+            const origin = resOrigin.newIbGib;
+
+            // 2. Mut8 (Mutate)
+            const resMut8 = await mut8({
+                src: origin,
+                dataToAddOrPatch: { mutated: 'data' },
+                dna: true,
+            });
+            const mutated = resMut8.newIbGib;
+
+            // 3. Put in space (should handle both if persisted correctly)
+            const resPut = await putInSpace({
+                space,
+                ibGibs: [origin, mutated],
+            });
+            iReckon(sir, resPut.success).isGonnaBeTrue();
+
+            // 4. Verify get
+            const resGet = await getFromSpace({
+                space,
+                addrs: [getIbGibAddr({ ibGib: mutated })],
+            });
+            iReckon(sir, resGet.success).isGonnaBeTrue();
+            // Using non-null assertion as we verified success
+            iReckon(sir, resGet.ibGibs![0].data!.mutated).isGonnaBe('data');
+        });
+
+        await ifWe(sir, 'should handle rel8 transform and persistence', async () => {
+            const space = new InnerSpace_V1(DEFAULT_INNER_SPACE_DATA_V1, undefined);
+            const gib = Factory_V1.primitive({ ib: 'gib' });
+
+            // 1. Create A and B
+            const resA = await Factory_V1.firstGen({ ib: 'A', dna: true, parentIbGib: gib });
+            const A = resA.newIbGib;
+            const resB = await Factory_V1.firstGen({ ib: 'B', dna: true, parentIbGib: gib });
+            const B = resB.newIbGib;
+            const bAddr = getIbGibAddr({ ibGib: B });
+
+            // 2. Rel8 A -> B (A links to B)
+            const resRel8 = await rel8({
+                src: A,
+                rel8nsToAddByAddr: { 'linked_to': [bAddr] },
+                dna: true,
+            });
+            const A_linked = resRel8.newIbGib;
+
+            // 3. Put in space
+            await putInSpace({
+                space,
+                ibGibs: [A, B, A_linked],
+            });
+
+            // 4. Verify relation
+            const resGet = await getFromSpace({
+                space,
+                addr: getIbGibAddr({ ibGib: A_linked }),
+            });
+            const retrieved = resGet.ibGibs![0];
+            iReckon(sir, retrieved.rel8ns!.linked_to).includes(bAddr);
         });
-        return metaspace;
-    } catch (error) {
-        console.error(`${lc} ${extractErrorMsg(error)}`);
-        throw error;
-    } finally {
-        if (logalot) { console.log(`${lc} complete.`); }
-    }
-}
-
-await respecfully(sir, 'metaspace setup itself', async () => {
-    await ifWe(sir, 'should init a metaspace', async () => {
-        const testSpaceName = 'TestSpaceName';
-
-        const metaspace = await getNewInitializedInMemoryMetaspaceForTesting({
-            defaultSpaceName: testSpaceName
+
+        await ifWe(sir, 'should handle fork persistence', async () => {
+            const space = new InnerSpace_V1(DEFAULT_INNER_SPACE_DATA_V1, undefined);
+            const gib = Factory_V1.primitive({ ib: 'gib' });
+
+            // 1. Create Root
+            const resRoot = await Factory_V1.firstGen({ ib: 'root', dna: true, parentIbGib: gib });
+            const root = resRoot.newIbGib;
+
+            // 2. Fork
+            const resFork = await fork({
+                src: root,
+                dna: true,
+                tjp: { timestamp: true },
+            });
+            const forkIbGib = resFork.newIbGib;
+
+            // 3. Put
+            await putInSpace({ space, ibGibs: [root, forkIbGib] });
+
+            // 4. Verify
+            const resGet = await getFromSpace({
+                space,
+                addr: getIbGibAddr({ ibGib: forkIbGib })
+            });
+            iReckon(sir, resGet.success).isGonnaBeTrue();
         });
 
-        iReckon(sir, metaspace.zeroSpace).asTo('metaspace should have a zero space').isGonnaBeTruthy();
     });
-});
 
-// await respecfully(sir, `[${InnerSpace_V1.name} specs]`, async () => {
-
-//     await testSpace_createAndInit({
-//         respecfulTitle: sir,
-//         // shortcircuitRespec: true,
-//         fnGetInitialSpaceData: async () => {
-//             return {
-//                 name: (await getUUID()).substring(0, 8),
-//                 uuid: await getUUID(),
-//             };
-//         },
-//         fnGetInitialSpaceRel8ns: () => {
-//             return Promise.resolve(undefined);
-//         },
-//         fnGetSpace: (initialData: any, initialRel8ns) => {
-//             return Promise.resolve(new InnerSpace_V1(initialData, initialRel8ns));
-//         },
-//     })
-
-//     await testSpace_putGetDelete({
-//         respecfulTitle: sir,
-//         // shortcircuitRespec: true,
-//         fnGetInitialSpaceData: async () => {
-//             return {
-//                 name: (await getUUID()).substring(0, 8),
-//                 uuid: await getUUID(),
-//             };
-//         },
-//         fnGetInitialSpaceRel8ns: () => {
-//             return Promise.resolve(undefined);
-//         },
-//         fnGetSpace: (initialData: any, initialRel8ns) => {
-//             return Promise.resolve(new InnerSpace_V1(initialData, initialRel8ns));
-//         },
-//     });
-
-//     await testSpace_persistTransformResult({
-//         respecfulTitle: sir,
-//         // shortcircuitRespec: true,
-//         fnGetInitialSpaceData: async () => {
-//             return {
-//                 name: (await getUUID()).substring(0, 8),
-//                 uuid: await getUUID(),
-//             };
-//         },
-//         fnGetInitialSpaceRel8ns: () => {
-//             return Promise.resolve(undefined);
-//         },
-//         fnGetSpace: (initialData: any, initialRel8ns) => {
-//             return Promise.resolve(new InnerSpace_V1(initialData, initialRel8ns));
-//         },
-//     });
-
-//     await testSpace_registerNewIbGib_GetLatest({
-//         respecfulTitle: sir,
-//         // shortcircuitRespec: true,
-//         fnGetInitialSpaceData: async () => {
-//             return {
-//                 name: (await getUUID()).substring(0, 8),
-//                 uuid: await getUUID(),
-//             };
-//         },
-//         fnGetInitialSpaceRel8ns: () => {
-//             return Promise.resolve(undefined);
-//         },
-//         fnGetSpace: (initialData: any, initialRel8ns) => {
-//             return Promise.resolve(new InnerSpace_V1(initialData, initialRel8ns));
-//         },
-//         testLatestIterations: 5,
-//     });
-
-// });
-
-
-
-// await respecfully(sir, 'reconciliation', async () => {
-//     const createSpace = async (name: string): Promise<InnerSpace_V1> => {
-//         const spaceData: InnerSpaceData_V1 = {
-//             name,
-//             classname: InnerSpace_V1.name,
-//             uuid: await getUUID(),
-//         };
-//         const space = new InnerSpace_V1(spaceData);
-//         await space.initialized;
-//         return space;
-//     };
-
-//     const testSpaceName = 'TestSpaceName';
-
-//     // common setup for reconciliation tests
-//     const metaspace: MetaspaceService = await getNewInitializedInMemoryMetaspaceForTesting({
-//         defaultSpaceName: testSpaceName
-//     });
-//     // const metaspace = new Metaspace_V1();
-//     // await metaspace.initialize();
-
-//     await ifWe(sir, 'should sync a new timeline to an empty destination space', async () => {
-//         // ARRANGE
-//         const local_space = await createSpace('local');
-//         const outer_space = await createSpace('outer');
-
-//         // Create a timeline in local_space using the new timeline-api
-//         const { newIbGib: timelineV1 } = await createTimeline({
-//             parentIb: 'test',
-//             ib: 'my test timeline',
-//             data: { foo: 'bar' },
-//             metaspace,
-//             space: local_space,
-//         });
-
-//         const timelineV2 = await mut8Timeline({
-//             timeline: timelineV1,
-//             mut8Opts: { dataToAddOrPatch: { foo: 'rab' } },
-//             metaspace,
-//             space: local_space,
-//         });
-
-//         // Get history for sync
-//         const historyInfo = await getHistory({
-//             timeline: timelineV2,
-//             includeDna: true,
-//             metaspace,
-//             space: local_space,
-//         });
-
-//         const timelineIbGibs = [
-//             ...(Object.values(historyInfo.dnaMap ?? {})),
-//             ...historyInfo.orderedPastIbGibs,
-//             historyInfo.headIbGib,
-//         ];
-//         const timelineAddrs = timelineIbGibs.map(x => getIbGibAddr({ ibGib: x }));
-//         const tjpAddr = getTjpAddr({ ibGib: timelineV1 });
-
-//         // ensure outer_space is empty // there is no such functionality
-//         // const resGetAddrsOuterBefore = await outer_space.getAddrs({});
-//         // iReckon(sir, 'outer space should be empty initially', resGetAddrsOuterBefore.data.addrs.length, 0);
-
-//         // ACT
-//         // const syncOpts: SyncSpaceOptionsIbGib = {
-//         //     ib: 'sync opts',
-//         //     gib: 'sync_opts_gib',
-//         //     data: {
-//         //         cmdModifiers: ['sync'],
-//         //         ibGibAddrs: timelineAddrs,
-//         //     },
-//         //     ibGibs: timelineIbGibs,
-//         // } as any;
-
-//         // // metaspace.syncIbGibs
-//         // putInSpace({})
-//         // const resSync = await outer_space.put(syncOpts);
-
-//         // ASSERT
-//         // iReckon(sir, `sync result success should be true. res: ${pretty(resSync)}`, resSync.data.success, true);
-//         // iReckon(sir, resSync?.data?.success).asTo(`sync result success`).isGonnaBeTrue();
-
-//         // const resGetAddrsOuterAfter = await outer_space.getAddrs({});
-//         // iReckon(sir, 'outer space should have all timeline ibgibs after sync', resGetAddrsOuterAfter.data.addrs.length, timelineAddrs.length);
-
-//         // const resGetLatest = await outer_space.getLatestAddrs({ data: { ibGibAddrs: [tjpAddr] } } as any);
-//         // const resGetLatest = getLatestAddrs({
-//         //     tjpAddrs: tjpAddrs,
-//         //     space: outer_space,
-//         // });
-//         // iReckon(sir, 'latest addr in outer space should match latest from local', resGetLatest.data.latestAddrsMap[tjpAddr], getIbGibAddr({ ibGib: timelineV2 }));
-//     });
-
-// });
+});

package/src/witness/space/space-helper.mts

@@ -2693,11 +2693,49 @@ export async function lockSpace({
                     expirationUTC: getExpirationUTCString({ seconds: secondsValid }),
                 }
             } as IbGibSpaceLockIbGib;
-            const resPut = await putInSpace({ ibGib: resLockIbGib, force: true, space });
-            if (resPut.success) {
-                resLockIbGib.data!.success = true;
+
+            // We must use space.witness (via argy) directly here instead of
+            // `putInSpace` helper, because we need to check
+            // `addrsAlreadyHave`. If the space already has the addr, then
+            // we have lost a race condition and the space is ALREADY locked.
+            const argPut = await space.argy({
+                ibMetadata: getSpaceArgMetadata({ space }),
+                argData: {
+                    cmd: 'put',
+                    force: true,
+                    ibGibAddrs: [spaceLockAddr],
+                },
+                ibGibs: [resLockIbGib],
+            });
+            const resPut = await space.witness(argPut);
+
+            if (resPut.data?.success) {
+                if ((resPut.data.addrsAlreadyHave ?? []).includes(spaceLockAddr)) {
+                    // Race condition lost! The lock was put by someone else in the interim.
+                    if (logalot) { console.log(`${lc} racelost! addrsAlreadyHave includes spaceLockAddr (${spaceLockAddr}) (I: 2e8a1562947c40698110b64251141753)`); }
+
+                    // get the existing lock that beat us
+                    const getLockRace = await getFromSpace({
+                        addr: spaceLockAddr, space, force: true
+                    });
+                    if (getLockRace.success && getLockRace.ibGibs?.length === 1) {
+                        const existingLockRace = getLockRace.ibGibs[0] as IbGibSpaceLockIbGib;
+                        resLockIbGib = clone(existingLockRace) as IbGibSpaceLockIbGib;
+                        resLockIbGib.data!.alreadyLocked = true;
+                        resLockIbGib.data!.success = false;
+                    } else {
+                        // Should be unreachable if addrsAlreadyHave is true, but handle gracefully
+                        const emsg = `${lc} (UNEXPECTED) addrsAlreadyHave true, but couldn't get lock? (E: 8374a2b6628b49369363bc5843105763)`;
+                        console.error(emsg);
+                        resLockIbGib.data!.success = false;
+                        resLockIbGib.data!.errorMsg = emsg;
+                    }
+                } else {
+                    // Success! We put the lock and it was new.
+                    resLockIbGib.data!.success = true;
+                }
             } else {
-                const emsg = `${lc} there was an error putting the lock in the space: ${resPut.errorMsg}`;
+                const emsg = `${lc} there was an error putting the lock in the space: ${resPut.data?.errors?.join('|')}`;
                 resLockIbGib.data!.success = false;
                 resLockIbGib.data!.errorMsg = emsg;
                 console.error(emsg);

package/src/witness/space/space-helper.respec.mts

@@ -0,0 +1,42 @@
+import { respecfully, ifWe, iReckon } from '@ibgib/helper-gib/dist/respec-gib/respec-gib.mjs';
+import { InnerSpace_V1 } from './inner-space/inner-space-v1.mjs';
+import { DEFAULT_INNER_SPACE_DATA_V1 } from './inner-space/inner-space-types.mjs';
+import { lockSpace, unlockSpace } from './space-helper.mjs';
+
+const maam = `[${import.meta.url}]`, sir = maam;
+
+await respecfully(sir, 'space-helper', async () => {
+
+    await respecfully(sir, 'lockSpace', async () => {
+
+        await ifWe(sir, 'should fail if two locks are acquired simultaneously on the same scope (race condition check)', async () => {
+            const space = new InnerSpace_V1(DEFAULT_INNER_SPACE_DATA_V1, undefined);
+
+            // initialize the space first (often required for internal structures)
+            await space.initialized;
+
+            const scope = 'test-lock-scope';
+            const secondsValid = 5;
+
+            // Try to acquire lock simultaneously from two "instances"
+            const p1 = lockSpace({ space, scope, secondsValid, instanceId: 'A' });
+            const p2 = lockSpace({ space, scope, secondsValid, instanceId: 'B' });
+
+            const [res1, res2] = await Promise.all([p1, p2]);
+
+            // Expectation: Only one should succeed
+            const success1 = res1.data?.success;
+            const success2 = res2.data?.success;
+
+            // If both verify, we have a problem (race condition)
+            // We reckon that NOT both are true.
+            iReckon(sir, success1 && success2).asTo('both locks acquired (mutual exclusion failed)').isGonnaBeFalse();
+
+            // Clean up
+            await unlockSpace({ space, scope, instanceId: 'A' });
+            await unlockSpace({ space, scope, instanceId: 'B' });
+        });
+
+    });
+
+});

package/tmp.md

@@ -0,0 +1,11 @@
+OK, ty. The space-wide sync approach is not tenable. That is like trying to sync Alice's entire logical drive with Bob's entire logical drive instead of a particular folder on the drive. Your thinking that a single Domain IbGib does not contain many timelines is faulty. A dependency graph of a "single" domain may contain multiple, or even many/a great many, timelines. Think of this like in set theory and we are creating an isomorphic projection of nodes. I say isomorphic and not homomorphic, because we may have to do merges for timelines, so it really is a "one-way" projection. Though obviously, with "sync" being bi-directional, we are ultimately converging on both endpoints having "equivalent" timelines (there may be orphans on one and/or the other after merges, with either endpoint effectively doing a "rebase"). So our sync process has to start with getting a "live" dependency graph of a single domain ibgib. We can actually do multiple domain ibgibs, and then unify the entire dependency graph in the sync transmission ibgib, but I think it's best to just build for the single ibgib scenario. You can look at@beautifulMention, but I would really recommend looking at the entire @beautifulMentionfile. This is a non-trivial recursive function, but you should be able to fully grok it by looking at both the jsdocs/comments in that file and the code itself. Always look at the code itself of course!
+
+That dependency graph comes in the form a @beautifulMention as defined by this:
+
+```
+/**
+ * Map of addr -> ibGib
+ */
+export type FlatIbGibGraph = { [addr: string]: IbGib_V1 };
+```
+