@ibgib/core-gib 0.1.38 → 0.1.40

package/src/sync/sync-conflict-adv-multitimelines.respec.mts

@@ -14,29 +14,26 @@ import { clone, delay, extractErrorMsg, pretty } from '@ibgib/helper-gib/dist/he
 import { getIbGibAddr } from '@ibgib/ts-gib/dist/helper.mjs';
 import { IbGibData_V1, IbGib_V1 } from '@ibgib/ts-gib/dist/V1/types.mjs';
 
+import { GLOBAL_LOG_A_LOT } from '../core-constants.mjs';
+import { TestTransformer, getTestKeystoneServiceHelper } from '../test-helpers.mjs';
+import { TestMut8Info, } from '../test-types.mjs';
 import { SyncSagaCoordinator } from './sync-saga-coordinator.mjs';
 import { getFromSpace } from '../witness/space/space-helper.mjs';
 import { Metaspace_Innerspace } from '../witness/space/metaspace/metaspace-innerspace/metaspace-innerspace.mjs';
 import { InnerSpace_V1 } from '../witness/space/inner-space/inner-space-v1.mjs';
-import { createTimelineRootTestHelper, getTestKeystoneServiceHelper } from '../test-helpers.mjs';
-import { appendToTimeline, createTimeline, mut8Timeline } from '../timeline/timeline-api.mjs';
 import { SyncPeerInnerspace_V1 } from './sync-peer/sync-peer-innerspace/sync-peer-innerspace-v1.mjs';
 import { DEFAULT_INNER_SPACE_DATA_V1 } from '../witness/space/inner-space/inner-space-types.mjs';
-import { getIbGibsFromCache_fallbackToSpaces, getTjpAddr, toDto } from '../common/other/ibgib-helper.mjs';
+import { getIbGibsFromCache_fallbackToSpaces, getTjpAddr, } from '../common/other/ibgib-helper.mjs';
 import { SyncSagaInfo } from './sync-types.mjs';
-import { fnObs } from '../common/pubsub/observer/observer-helper.mjs';
 import { getDependencyGraph, graphsAreEquivalent } from '../common/other/graph-helper.mjs';
-import { ErrorIbGib_V1 } from '../common/error/error-types.mjs';
 import { SYNC_PEER_INNERSPACE_DEFAULT_DATA_V1 } from './sync-peer/sync-peer-innerspace/sync-peer-innerspace-constants.mjs';
 import { SyncConflictStrategy } from './sync-constants.mjs';
-import { GRAFT_BASE_REL8N_NAME, GRAFT_INFO_REL8N_NAME, GRAFT_ORPHAN_REL8N_NAME } from './graft-info/graft-info-constants.mjs';
+import { getHistory } from '../timeline/timeline-api.mjs';
 
-const logalot = false;
+const logalot = GLOBAL_LOG_A_LOT;
 const lc = sir;
 
-
 interface TestData extends IbGibData_V1 {
-    type?: string;
     /**
      * field that is made in a common (pre-sync) ibgib
      */
@@ -47,9 +44,10 @@ interface TestData extends IbGibData_V1 {
 
 const TEST_REL8N_NAME = 'testrel8n';
 
-await respecfully(sir, `Two different fields and rel8d`, async () => {
+await respecfully(sir, `Multi-round/timeline permutations`, async () => {
+
+    // #region Init/Setup
 
-    // 1. Setup Spaces
     const metaspace = new Metaspace_Innerspace(undefined);
     await metaspace.initialize({
         getFnAlert: () => async ({ title, msg }) => { console.log(`[Alert] ${title}: ${msg}`); },
@@ -77,316 +75,341 @@ await respecfully(sir, `Two different fields and rel8d`, async () => {
     });
     await destSpace.initialized;
 
-    // 2. Seed common History (v0 -> v1)
-    console.log(`${lc} Creating common History...`);
-    const alpha_v0 = await createTimelineRootTestHelper<TestData>({
-        /**
-         * greek letters are distinct timelines
-         */
-        ib: 'alpha',
-        data: { type: 'alpha', },
-        space: sourceSpace,
-    });
-    // Create v1 (common)
-    /**
-     * **created** on source, but sync will take it to dest
-     */
-    const alpha_v1_common_onSource = await mut8Timeline<TestData>({
-        timeline: alpha_v0,
-        mut8Opts: {
-            mut8Ib: alpha_v0.ib + '_common',
-            dataToAddOrPatch: { commonField: 'common yo' }
-        },
-        metaspace,
-        space: sourceSpace,
-    });
-    const tjpAddr =
-        getTjpAddr({ ibGib: alpha_v0, defaultIfNone: 'incomingAddr' }) ??
-        getIbGibAddr({ ibGib: alpha_v0 });
-    // Sync alpha to dest immediately so they start synced
-    // must get the entire dependency graph for alpha
-    const depGraph_alpha_v1Andcommon = await getDependencyGraph({
-        ibGibAddrs: [tjpAddr],
-        space: sourceSpace,
-        live: true,
-    }) ?? {};
-    console.log(`${lc} depGraph_testRootAndV1Common: ${pretty(depGraph_alpha_v1Andcommon)}`)
-    if (Object.keys(depGraph_alpha_v1Andcommon).length === 0) {
-        throw new Error(`(UNEXPECTED) depGraph_testRootAndV1Common empty? (E: 39b4d855ffa65476084b4123786da826)`);
-    }
-    // put the entire graph into the destspace, but...
-    await metaspace.put({ ibGibs: Object.values(depGraph_alpha_v1Andcommon), space: destSpace });
-    const resGetDest = await getFromSpace({ space: destSpace, addr: getIbGibAddr({ ibGib: alpha_v1_common_onSource }) });
-    if (!resGetDest.success || !resGetDest.ibGibs || resGetDest.ibGibs.length === 0) {
-        throw new Error(`Failed to retrieve v1_Common_onDest from destSpace. (E: 40c67811eba14f729880a46dcbb65126)`);
+    const testTransformer = new TestTransformer(metaspace, sourceSpace, destSpace);
+
+    if (logalot) { console.log(`${lc} Setting up Coordinators...`); }
+    const mockKeystone = await getTestKeystoneServiceHelper();
+    const senderCoordinator = new SyncSagaCoordinator(mockKeystone);
+    const receiverCoordinator = new SyncSagaCoordinator(mockKeystone);
+
+    async function newTestPeer(): Promise<SyncPeerInnerspace_V1> {
+        const peer = new SyncPeerInnerspace_V1(clone(SYNC_PEER_INNERSPACE_DEFAULT_DATA_V1));
+        await peer.initialized;
+        await peer.initializeSender({
+            senderSpace: sourceSpace,
+            receiverSpace: destSpace,
+            receiverCoordinator: receiverCoordinator,
+            receiverMetaspace: metaspace,
+        });
+        return peer;
     }
+
+    // #endregion Init/Setup
+
+    // #region Round 1: Seed common history
+
     /**
-     * same as v1_common
+     * not sure if we're going to do anything with the round info itself
      */
-    const alpha_v1_common_onDest = resGetDest.ibGibs[0];
-    // ...only register the main ibgibs
-    await metaspace.registerNewIbGib({ ibGib: alpha_v0, space: destSpace });
-    await metaspace.registerNewIbGib({ ibGib: alpha_v1_common_onDest, space: destSpace }); // it's the "on source" one, but only because
+    const _r1 = testTransformer.newRound({
+        name: 'r1_seedCommonHistory',
+        description: 'Create alpha v0 and v1 on source, sync to dest so both v0 and v1 are established as synced.',
+    });
 
+    // #region r1 setup
 
-    // 3. Create Divergence(s) (v2source vs v2dest), i.e. "simultaneous" parallel edits
-    // NOTE: source vs dest here is to indicate the location the edit is made.
-    // syncing will obviously blur this line.
-    console.log(`${lc} Creating Divergence...`);
+    if (logalot) { console.log(`${lc} Creating common History...`); }
+    const r1_alpha_v0_source = await testTransformer.create({
+        atom: 'alpha',
+        in: 'source',
+        name: 'r1_alpha_v0_source', // should be auto-calculated?
+    });
 
-    // #region edit on source
+    // Create v1 (common) - will be synced to dest
+    const r1_alpha_v1_source_common = await testTransformer.mut8({
+        stepInfo: r1_alpha_v0_source,
+        strField: 'commonField',
+        name: 'r1_alpha_v1_source_common'
+    });
+    const alpha_tjpAddr =
+        getTjpAddr({ ibGib: r1_alpha_v0_source.ibGib, defaultIfNone: 'incomingAddr' })!;
 
-    // Source: v1 (common) -> v2source (Edit Field A and rel8 beta)
+    // #endregion r1 setup
 
-    const beta_v0_source = await createTimelineRootTestHelper<TestData>({
-        ib: 'beta',
-        data: {
-            fieldA: 'beta field A created on source',
-        },
-        space: sourceSpace,
+    await respecfully(sir, `r1 verify pre`, async () => {
+        await ifWeMight(sir, 'dest should NOT have alpha', async () => {
+            const resGet = await getFromSpace({
+                space: destSpace,
+                addr: alpha_tjpAddr,
+            });
+            // When timeline doesn't exist, getFromSpace returns success:false
+            iReckon(sir, resGet.success).asTo('getFromSpace should return false for missing timeline').isGonnaBeFalse();
+            iReckon(sir, resGet.ibGibs?.length ?? 0).asTo('Dest should NOT have alpha timeline yet').isGonnaBe(0);
+        });
     });
-    const betaAddr_v0 = getIbGibAddr({ ibGib: beta_v0_source });
-
-    const alpha_v2_source_sansBeta = await mut8Timeline<TestData>({
-        timeline: alpha_v1_common_onSource,
-        mut8Opts: {
-            mut8Ib: alpha_v0.ib + '_v2source',
-            dataToAddOrPatch: { fieldA: 'source_edit' }
-        },
+
+    const r1_syncSaga = await senderCoordinator.sync({
+        peer: await newTestPeer(),
+        localSpace: sourceSpace,
         metaspace,
-        space: sourceSpace,
+        domainIbGibs: [r1_alpha_v1_source_common.ibGib],
+        conflictStrategy: SyncConflictStrategy.optimisticWithLCS,
+        useSessionIdentity: false,
     });
-    const alpha_v3_source_rel8beta = await appendToTimeline({
-        timeline: alpha_v2_source_sansBeta,
-        metaspace,
-        space: sourceSpace,
-        rel8nInfos: [
-            { rel8nName: TEST_REL8N_NAME, ibGibs: [beta_v0_source] }
-        ],
+
+    await r1_syncSaga.done;
+    if (logalot) { console.log(`${lc} r1_syncSaga Complete.`); }
+
+    await respecfully(sir, `r1 verify post`, async () => {
+        await ifWeMight(sir, 'dest should have alpha', async () => {
+            // alpha's full dep graph should exist on dest
+            const [alpha_dest] = await getIbGibsFromCache_fallbackToSpaces({
+                addrs: [r1_alpha_v0_source.addr],
+                space: destSpace,
+            });
+            iReckon(sir, alpha_dest).asTo('alpha exists in dest').isGonnaBeTruthy();
+            if (alpha_dest) {
+                const depGraph_alpha_source = await getDependencyGraph({ ibGib: r1_alpha_v0_source.ibGib, space: sourceSpace });
+                const depGraph_alpha_dest = await getDependencyGraph({ ibGib: alpha_dest, space: destSpace });
+                const alphaDepsAreEqual = graphsAreEquivalent({
+                    graphA: depGraph_alpha_source, graphB: depGraph_alpha_dest
+                });
+                iReckon(sir, alphaDepsAreEqual).asTo('alpha got synced and graphs are equal').isGonnaBeTrue();
+            }
+        });
     });
-    /**
-     * since we're doing this first, this will be the base in our graft
-     */
-    const baseAddr = getIbGibAddr({ ibGib: alpha_v3_source_rel8beta });
 
-    // #endregion edit on source
+    // Get alpha_v1_common from destSpace for Round 2
+    const resGetDest = await getFromSpace({ space: destSpace, addr: alpha_tjpAddr });
+    if (!resGetDest.success || !resGetDest.ibGibs || resGetDest.ibGibs.length === 0) {
+        throw new Error(`Failed to retrieve alpha from destSpace after sync. (E: 40c67811eba14f729880a46dcbb65126)`);
+    }
+    const alpha_v1_common_onDest = resGetDest.ibGibs[0];
 
-    /**
-     * timestamp/timestampMs drives orphan/base timeline selection in
-     * graftTimelines
-     */
-    await delay(16);
+    // #endregion Round 1: Seed common history
 
+    // #region Round 2: Create Divergence (v2source vs v2dest) - "simultaneous" parallel edits
 
-    // #region edit on dest
-    // Dest: v1 (common) -> alpha_v2_dest (Edit Field B)
-    const alpha_v2_dest = await mut8Timeline<TestData>({
-        timeline: alpha_v1_common_onDest,
-        mut8Opts: {
-            mut8Ib: alpha_v0.ib + '_v2dest',
-            dataToAddOrPatch: { fieldB: 'dest_edit' }
-        },
-        metaspace,
-        space: destSpace,
+    const _r2 = testTransformer.newRound({
+        name: 'r2_divergent_edits',
+        description: 'Create conflicts on alpha, add beta relation on source, separate edit on dest'
     });
-    /**
-     * since we're doing this second (i.e., later temporally), this will be
-     * the orphan in our graft
-     */
-    const orphanAddr = getIbGibAddr({ ibGib: alpha_v2_dest });
 
-    // Verify Divergence
-    console.log(`${lc} Divergence created.`);
+    // #region r2 source edits
 
+    if (logalot) { console.log(`${lc} Creating Divergence...`); }
 
-    // 4. Run Sync (Optimistic)
-    console.log(`${lc} Setting up Coordinators...`);
-    const mockKeystone = await getTestKeystoneServiceHelper();
-    const senderCoordinator = new SyncSagaCoordinator(mockKeystone);
-    const receiverCoordinator = new SyncSagaCoordinator(mockKeystone);
+    // Source: Create beta, mutate alpha fieldA, add beta relation
+    const r2_beta_v0_source = await testTransformer.create({
+        atom: 'beta',
+        in: 'source',
+        data: { fieldA: 'beta field A created on source' },
+        name: 'r2_beta_v0_source'
+    });
+    const r2_alpha_v2_source_arbitraryMut8 = await testTransformer.mut8({
+        ibGib: r1_alpha_v1_source_common.ibGib,
+        in: 'source',
+        strField: 'fieldA',
+        name: 'r2_alpha_v2_source_arbitraryMut8',
+        comments_snake_plus_CamelCase: 'editedOnSource',
+    });
+    const r2_alpha_v3_source_rel8dBeta = await testTransformer.rel8({
+        stepInfo: r2_alpha_v2_source_arbitraryMut8,
+        in: 'source',
+        targetIbGibs: [r2_beta_v0_source.ibGib],
+        rel8nName: TEST_REL8N_NAME,
+        name: 'r2_alpha_v3_source_rel8dBeta'
+    });
 
-    const peer = new SyncPeerInnerspace_V1(clone(SYNC_PEER_INNERSPACE_DEFAULT_DATA_V1));
-    await peer.initialized;
-    await peer.initializeSender({
-        senderSpace: sourceSpace,   // "Client"
-        receiverSpace: destSpace,   // "Server"
-        receiverCoordinator,
-        receiverMetaspace: metaspace,
+    // #endregion r2 source edits
+
+    // #region r2 dest edits
+
+    // Dest: Mutate alpha fieldB (different field than source)
+    const r2_alpha_v2_dest_mut8FieldB = await testTransformer.mut8({
+        ibGib: alpha_v1_common_onDest,
+        in: 'dest',
+        strField: 'fieldB',
+        name: 'r2_alpha_v2_dest_mut8FieldB',
+        comments_snake_plus_CamelCase: 'editedOnDest',
     });
 
+    if (logalot) { console.log(`${lc} Divergence created.`); }
+
+    // #endregion r2 dest edits
+
     // Verify Receiver has correct KV (Pre-Sync Check)
     // This ensures the conflict precondition exists.
-    await ifWeMight(sir, 'verify receiver KV pre-sync', async () => {
-        try {
-            const destKV = await receiverCoordinator.getKnowledgeMap({
-                space: destSpace,
-                metaspace,
-                domainIbGibs: [alpha_v1_common_onDest]
-            });
-            const v1TjpAddr = getTjpAddr({ ibGib: alpha_v1_common_onDest, defaultIfNone: 'incomingAddr' }) ?? getIbGibAddr({ ibGib: alpha_v1_common_onDest });
+    await respecfully(sir, `r2 verify pre`, async () => {
+        await ifWeMight(sir, 'dest has alpha v1 common', async () => {
+            try {
+                const destKV = await receiverCoordinator.getKnowledgeMap({
+                    space: destSpace,
+                    metaspace,
+                    domainIbGibs: [alpha_v1_common_onDest]
+                });
+                const alpha_v1_common_tjpAddr_onDest =
+                    getTjpAddr({ ibGib: alpha_v1_common_onDest, defaultIfNone: 'incomingAddr' })!;
 
-            // Actually v1 has tjp rel8n.
-            const destTip = destKV[v1TjpAddr];
-            iReckon(sir, !!destTip).asTo(`Dest KV has timeline tip for ${v1TjpAddr}`).isGonnaBeTruthy();
-            if (!destTip) {
-                throw new Error(`Test Setup Fail: Dest Space does not have index for timeline ${v1TjpAddr}. Seeding failed. (E: c194a80b4e4877b77826c37a1753b826)`);
+                const destTip = destKV[alpha_v1_common_tjpAddr_onDest];
+                iReckon(sir, !!destTip).asTo(`Dest KV has timeline tip for ${alpha_v1_common_tjpAddr_onDest}`).isGonnaBeTruthy();
+                if (!destTip) {
+                    throw new Error(`Test Setup Fail: Dest Space does not have index for timeline ${alpha_v1_common_tjpAddr_onDest}. Seeding failed. (E: c194a80b4e4877b77826c37a1753b826)`);
+                }
+            } catch (error) {
+                console.error(`${lc} ${extractErrorMsg(error)}`);
+                iReckon(sir, true).asTo('getKnowledgeMap errored out').isGonnaBeFalse();
             }
-        } catch (error) {
-            console.error(`${lc} ${extractErrorMsg(error)}`);
-            iReckon(sir, true).asTo('getKnowledgeMap errored out').isGonnaBeFalse();
-        }
+        });
     });
 
-    console.log(`${lc} Running Sync (ConflictStrategy: optimistic)...`);
+    if (logalot) { console.log(`${lc} Running Sync (ConflictStrategy: optimistic)...`); }
 
-    let resSync: SyncSagaInfo | undefined;
+    let r2_syncSaga: SyncSagaInfo | undefined;
     try {
-        console.dir(sourceSpace)
-        console.dir(destSpace)
-        resSync = await senderCoordinator.sync({
-            peer,
+        if (logalot) { console.dir(sourceSpace) }
+        if (logalot) { console.dir(destSpace) }
+        r2_syncSaga = await senderCoordinator.sync({
+            peer: await newTestPeer(),
             localSpace: sourceSpace,
             metaspace,
-            domainIbGibs: [alpha_v3_source_rel8beta],
+            domainIbGibs: [r2_alpha_v3_source_rel8dBeta.ibGib],
             conflictStrategy: SyncConflictStrategy.optimisticWithLCS,
             useSessionIdentity: false,
         });
 
-        const sublc = `${lc}[updates$]`;
-        /**
-         * I have added this so you can see how to subscribe to an ibgib
-         * observable using {@link fnObs}.
-         */
-        const subscription = await resSync.updates$.subscribe(fnObs({
-            next: async (ctxIbGib) => {
-                // console.log(`${sublc} next fired. ${JSON.stringify(ctxIbGib)}`);
-                console.log(`${sublc} next fired. (I: e68d8894bac8800f9f3430e8a38d6626)`);
-            },
-            error: async (e: ErrorIbGib_V1) => {
-                if (e.data) {
-                    console.error(`${sublc} error fired. error: ${JSON.stringify(e.data)} (E: eddf17f76a486b9c5a2f4ee86ed38b26)`);
-                } else {
-                    console.dir(e);
-                    console.error(`${sublc} error fired. error: ${extractErrorMsg(e)} (E: af9c3b6f1c88befeff77ca46111b3826)`);
-                }
-            },
-            complete: async () => {
-                console.log(`${sublc} complete fired`);
-            },
-        }));
-
-        console.log(`${lc} awaiting resSync.done`)
-        await resSync.done;
+        if (logalot) { console.log(`${lc} awaiting r2_syncSaga.done`) }
+        await r2_syncSaga.done;
 
-        console.log(`${lc} Sync Complete.`);
+        if (logalot) { console.log(`${lc} r2_syncSaga Complete.`); }
     } catch (e) {
         console.error(`${lc} Sync Failed with Error:`, e);
         iReckon(sir, false).asTo(`Sync failed with error: ${e}`).isGonnaBeTruthy();
         return; // Exit test early
     }
 
-    // 5. Verification
     // Expectation: Both Spaces should now have a NEW tip (V3) that merges v2source and v2dest.
+    await respecfully(sir, `r2 verify post`, async () => {
 
-    const resSourceTip = await getFromSpace({ space: sourceSpace, addr: getIbGibAddr({ ibGib: alpha_v3_source_rel8beta }) });
-
-    await respecfully(sir, `verify merge`, async () => {
         // Retrieve updated KV from Source (or check what happened to v2source)
         // Ideally, we just check the source space for the timeline tip
         // The timeline tip for alpha/v0 should now be NEW.
 
         try {
             // Get the KV for the Source Space
-            const sourceKV_afterSync = await senderCoordinator.getKnowledgeMap({
+            const alpha_sourceKV_afterSync = await senderCoordinator.getKnowledgeMap({
                 space: sourceSpace,
                 metaspace,
-                domainIbGibs: [alpha_v0] // We want to know the tip of this timeline
+                domainIbGibs: [r1_alpha_v0_source.ibGib] // We want to know the tip of this timeline
             });
-            const tjpAddr =
-                getTjpAddr({ ibGib: alpha_v0, defaultIfNone: 'incomingAddr' }) ??
-                getIbGibAddr({ ibGib: alpha_v0 });
-
-            if (logalot) { console.log(`${lc} getKnowledgeMap returned. sourceKV_afterSync: ${pretty(sourceKV_afterSync)} (I: e8780cda37c8b2a46eeb85786874e926)`); }
+            if (logalot) { console.log(`${lc} getKnowledgeMap returned. sourceKV_afterSync: ${pretty(alpha_sourceKV_afterSync)} (I: e8780cda37c8b2a46eeb85786874e926)`); }
+            const alpha_source_tipAddr = alpha_sourceKV_afterSync[alpha_tjpAddr];
+            if (logalot) { console.log(`${lc} alpha_source_tipAddr: ${alpha_source_tipAddr} (I: 34590f29c9b706ba04a54b0f633a6426)`); }
+            if (!alpha_source_tipAddr) {
+                throw new Error(`Source Space missing timeline tip for ${alpha_tjpAddr} (E: ec95980b9c980c5c5870812e15e43826)`);
+            }
 
-            const sourceTipAddr = sourceKV_afterSync[tjpAddr];
-            if (!sourceTipAddr) {
-                throw new Error(`Source Space missing timeline tip for ${tjpAddr} (E: ec95980b9c980c5c5870812e15e43826)`);
+            const alpha_destKV_afterSync = await senderCoordinator.getKnowledgeMap({
+                space: destSpace,
+                metaspace,
+                domainIbGibs: [r1_alpha_v0_source.ibGib] // We want to know the tip of this timeline
+            });
+            if (logalot) { console.log(`${lc} getKnowledgeMap returned. destKV_afterSync: ${pretty(alpha_destKV_afterSync)} (I: e8780cda37c8b2a46eeb85786874e926)`); }
+            const alpha_dest_tipAddr = alpha_destKV_afterSync[alpha_tjpAddr];
+            if (logalot) { console.log(`${lc} alpha_dest_tipAddr: ${alpha_dest_tipAddr} (I: afac71eba4e6d3f3c47952680ad8b826)`); }
+            if (!alpha_dest_tipAddr) {
+                throw new Error(`dest Space missing timeline tip for ${alpha_tjpAddr} (E: 30b018c6349917aa28c9f538fa567826)`);
             }
+            await ifWeMight(sir, 'tip addrs', async () => {
+                iReckon(sir, alpha_source_tipAddr).asTo('source/dest have same tip addrs').isGonnaBe(alpha_dest_tipAddr);
+            })
 
             // Fetch the new tip
-            const resTip = await getFromSpace({ space: sourceSpace, addr: sourceTipAddr });
-            const newTip = resTip.ibGibs![0] as IbGib_V1<TestData>;
+            const resGet_alpha_source_tipAddr = await getFromSpace({ space: sourceSpace, addr: alpha_source_tipAddr });
+            const gotten_alpha_source_tipIbGib = resGet_alpha_source_tipAddr.ibGibs![0] as IbGib_V1<TestData>;
 
-            await ifWeMight(sir, 'basics of alpha merge', async () => {
-                iReckon(sir, sourceTipAddr).asTo(`Source Tip (${sourceTipAddr}) should NOT be alpha_v3_source_rel8beta`).not.isGonnaBe(getIbGibAddr({ ibGib: alpha_v3_source_rel8beta }));
-                iReckon(sir, sourceTipAddr).asTo(`Source Tip (${sourceTipAddr}) should NOT be v2dest`).not.isGonnaBe(getIbGibAddr({ ibGib: alpha_v2_dest }));
+            if (logalot || true) {
+                console.log(`${lc} gotten_alpha_source_tipIbGib:\n${pretty(gotten_alpha_source_tipIbGib)} (I: e9c608c1fcb85f08d17d4af319d62726)`);
+            }
 
-                // Check Data: Should have BOTH edits
-                iReckon(sir, newTip.data!.fieldA).asTo('New Tip Data Field A').isGonnaBe('source_edit');
-                iReckon(sir, newTip.data!.fieldB).asTo('New Tip Data Field B').isGonnaBe('dest_edit');
+            // #region DEBUG SANITY CHECK
+            const resGetTjp = await getFromSpace({ space: sourceSpace, addr: alpha_tjpAddr });
+            const gottenTjp = resGetTjp.ibGibs![0] as IbGib_V1<TestData>;
+            debugger;
+            const history = await getHistory({
+                timeline: gotten_alpha_source_tipIbGib,
+                space: sourceSpace,
+                metaspace,
+                includeDna: true,
             });
-
-
-            // Check Graft Structure
-            // Look for 'graftinfo' rel8n
-
-            await ifWeMight(sir, 'graft info is valid', async () => {
-                if (!newTip.rel8ns) { throw new Error(`(UNEXPECTED) newTip.rel8ns falsy? (E: eb4078712ea2f02c7ee84b983ed77826)`); }
-                const graftInfoRel = newTip.rel8ns[GRAFT_INFO_REL8N_NAME];
-                iReckon(sir, graftInfoRel).asTo('New Tip should have graftinfo rel8n').isGonnaBeTruthy();
-                if (!graftInfoRel) { return; /* <<<< returns early, above reckoning fails */ }
-                iReckon(sir, graftInfoRel!.length).asTo('Only 1 graftinfo').isGonnaBe(1);
-
-                // Fetch Graft Info Stone
-                const resGraft = await getFromSpace({ space: sourceSpace, addr: graftInfoRel![0] });
-                const graftInfo = resGraft.ibGibs![0];
-
-                // Check Graft Relations (graftbase, graftorphan)
-                if (!graftInfo.rel8ns) { throw new Error(`(UNEXPECTED) graftInfo.rel8ns falsy? (E: 8e39e84e9e0813e09e8f6788ce488926)`); }
-                const baseRel = graftInfo.rel8ns[GRAFT_BASE_REL8N_NAME];
-                const orphanRel = graftInfo.rel8ns[GRAFT_ORPHAN_REL8N_NAME];
-
-                iReckon(sir, baseRel).asTo('Graft Base exists').isGonnaBeTruthy();
-                iReckon(sir, baseRel!.length).asTo('Graft Base length is 2').isGonnaBe(2);
-                iReckon(sir, orphanRel).asTo('Graft Orphan exists').isGonnaBeTruthy();
-                iReckon(sir, orphanRel!.length).asTo('Graft Orphan length is 1').isGonnaBe(1);
-                iReckon(sir, baseRel!.at(-1)).asTo('base rel8ns final addr will be baseAddr').isGonnaBe(baseAddr);
-                iReckon(sir, orphanRel![0]).asTo('orphan rel8ns will be later addr').isGonnaBe(orphanAddr);
+            debugger;
+            // #endregion DEBUG SANITY CHECK
+
+
+            await ifWeMight(sir, 'r2 basics of alpha merge', async () => {
+                iReckon(sir, alpha_source_tipAddr)
+                    .asTo(`Source Tip (${alpha_source_tipAddr}) should NOT be r2_alpha_v3_source_rel8dBeta`)
+                    .not.isGonnaBe(r2_alpha_v3_source_rel8dBeta.addr);
+                iReckon(sir, alpha_source_tipAddr)
+                    .asTo(`Source Tip (${alpha_source_tipAddr}) should NOT be r2_alpha_v2_dest_mut8FieldB`)
+                    .not.isGonnaBe(r2_alpha_v2_dest_mut8FieldB.addr);
+
+                // Check Data: Should have BOTH edits (using testTransformer-generated values)
+                const r2_source_mut8Info = r2_alpha_v2_source_arbitraryMut8.infos[0] as TestMut8Info;
+                const r2_dest_mut8Info = r2_alpha_v2_dest_mut8FieldB.infos[0] as TestMut8Info;
+
+                const a = gotten_alpha_source_tipIbGib.data![r2_source_mut8Info.key!];
+                const a2 = r2_source_mut8Info.value!;
+                console.log(`${a} should be ${a2}`)
+                iReckon(sir, gotten_alpha_source_tipIbGib.data![r2_source_mut8Info.key!]).asTo(`New Tip has source field ${r2_source_mut8Info.key!}`).isGonnaBe(r2_source_mut8Info.value!);
+
+                const b = gotten_alpha_source_tipIbGib.data![r2_dest_mut8Info.key!];
+                const b2 = r2_dest_mut8Info.value!;
+                console.log(`${b} should be ${b2}`)
+                iReckon(sir, gotten_alpha_source_tipIbGib.data![r2_dest_mut8Info.key!]).asTo(`New Tip has dest field ${r2_dest_mut8Info.key!}`).isGonnaBe(r2_dest_mut8Info.value!);
             });
 
-            await ifWeMight(sir, 'alpha and deps synced', async () => {
-                // alpha's full dep graph should exist on dest
-                const [beta_dest] = await getIbGibsFromCache_fallbackToSpaces({
-                    addrs: [betaAddr_v0],
+            await ifWeMight(sir, 'r2 alpha and deps synced', async () => {
+                // alpha's full dep graph should exist on dest, even though its
+                // timeline was grafted
+                const [alpha_dest] = await getIbGibsFromCache_fallbackToSpaces({
+                    addrs: [r1_alpha_v0_source.addr],
                     space: destSpace,
                 });
-                iReckon(sir, beta_dest).asTo('beta exists in dest').isGonnaBeTruthy();
-                if (beta_dest) {
-                    const depGraph_beta_source = await getDependencyGraph({ ibGib: beta_v0_source, space: sourceSpace });
-                    if (Object.keys(depGraph_alpha_v1Andcommon).length === 0) {
-                        throw new Error(`(UNEXPECTED) depGraph_testRootAndV1Common empty? (E: 39b4d855ffa65476084b4123786da826)`);
+                iReckon(sir, alpha_dest).asTo('alpha exists in dest').isGonnaBeTruthy();
+                if (alpha_dest) {
+                    try {
+                        const depGraph_alpha_source = await getDependencyGraph({
+                            ibGib: r1_alpha_v0_source.ibGib,
+                            live: true,
+                            space: sourceSpace
+                        });
+                        const depGraph_alpha_dest = await getDependencyGraph({
+                            ibGib: alpha_dest,
+                            live: true,
+                            space: destSpace
+                        });
+                        const alphaDepsAreEqual = graphsAreEquivalent({
+                            graphA: depGraph_alpha_source,
+                            graphB: depGraph_alpha_dest,
+                            slowButThorough: true,
+                        });
+                        iReckon(sir, alphaDepsAreEqual).asTo('alpha got synced and graphs are equal').isGonnaBeTrue();
+                    } catch (error) {
+                        console.error(`${lc} ${extractErrorMsg(error)}`);
+                        iReckon(sir, true).asTo('ERROR: alpha exists in dest').isGonnaBeFalse(); // fails
                     }
-                    const depGraph_beta_dest = await getDependencyGraph({ ibGib: beta_dest, space: destSpace });
-                    const betaDepsAreEqual = graphsAreEquivalent({
-                        graphA: depGraph_beta_source, graphB: depGraph_beta_dest
-                    });
-                    iReckon(sir, betaDepsAreEqual).asTo('beta got synced and graphs are equal').isGonnaBeTrue();
                 }
             });
 
-            await ifWeMight(sir, 'beta and deps synced', async () => {
+            await ifWeMight(sir, 'r2 beta and deps synced', async () => {
                 // beta's full dep graph should exist on dest
                 const [beta_dest] = await getIbGibsFromCache_fallbackToSpaces({
-                    addrs: [betaAddr_v0],
+                    addrs: [r2_beta_v0_source.addr],
                     space: destSpace,
                 });
                 iReckon(sir, beta_dest).asTo('beta exists in dest').isGonnaBeTruthy();
                 if (beta_dest) {
-                    const depGraph_beta_source = await getDependencyGraph({ ibGib: beta_v0_source, space: sourceSpace });
-                    if (Object.keys(depGraph_alpha_v1Andcommon).length === 0) {
-                        throw new Error(`(UNEXPECTED) depGraph_testRootAndV1Common empty? (E: 39b4d855ffa65476084b4123786da826)`);
-                    }
-                    const depGraph_beta_dest = await getDependencyGraph({ ibGib: beta_dest, space: destSpace });
+                    const depGraph_beta_source = await getDependencyGraph({
+                        ibGib: r2_beta_v0_source.ibGib,
+                        live: true,
+                        space: sourceSpace
+                    });
+                    const depGraph_beta_dest = await getDependencyGraph({
+                        ibGib: beta_dest,
+                        live: true,
+                        space: destSpace
+                    });
                     const betaDepsAreEqual = graphsAreEquivalent({
                         graphA: depGraph_beta_source,
                         graphB: depGraph_beta_dest,
@@ -403,4 +426,68 @@ await respecfully(sir, `Two different fields and rel8d`, async () => {
 
     });
 
+    // #endregion Round 2: Create Divergence (v2source vs v2dest) - "simultaneous" parallel edits
+
+    // #region Round 3: Multiple Timeline Conflicts
+
+    const _r3 = testTransformer.newRound({
+        name: 'r3_multiple_timeline_conflicts',
+        description: 'Both alpha AND beta have divergent edits on source vs dest - tests multiple simultaneous grafts'
+    });
+
+    // #region r3 source edits
+
+    if (logalot) { console.log(`${lc} Creating r3 divergent edits on source...`); }
+
+    // Source: Mutate alpha fieldC, mutate beta betaFieldA
+    // TODO: Add source edits here
+
+    // #endregion r3 source edits
+
+    // #region r3 dest edits
+
+    if (logalot) { console.log(`${lc} Creating r3 divergent edits on dest...`); }
+
+    // Dest: Mutate alpha fieldD, mutate beta betaFieldB
+    // TODO: Add dest edits here
+
+    // #endregion r3 dest edits
+
+    await respecfully(sir, `r3 verify pre`, async () => {
+        // TODO: Verify pre-sync state
+        await ifWeMight(sir, 'source has divergent alpha and beta', async () => {
+            // Verify source has its versions
+        });
+
+        await ifWeMight(sir, 'dest has divergent alpha and beta', async () => {
+            // Verify dest has its versions
+        });
+    });
+
+    if (logalot) { console.log(`${lc} Running r3 Sync...`); }
+
+    // TODO: Add sync operation here
+    // const r3_syncSaga = await senderCoordinator.sync({...});
+
+    await respecfully(sir, `r3 verify post`, async () => {
+        // TODO: Verify post-sync state
+
+        await ifWeMight(sir, 'r3 alpha merge has both edits', async () => {
+            // Verify alpha has fieldC (source) AND fieldD (dest)
+        });
+
+        await ifWeMight(sir, 'r3 beta merge has both edits', async () => {
+            // Verify beta has betaFieldA (source) AND betaFieldB (dest)
+        });
+
+        await ifWeMight(sir, 'r3 alpha and deps synced', async () => {
+            // Verify alpha's full dep graph on both spaces
+        });
+
+        await ifWeMight(sir, 'r3 beta and deps synced', async () => {
+            // Verify beta's full dep graph on both spaces
+        });
+    });
+
+    // #endregion Round 3: Multiple Timeline Conflicts
 });