@ibgib/core-gib 0.1.12 → 0.1.14

package/src/sync/sync-innerspace.respec.mts

@@ -1,289 +1,458 @@
-/**
- * @module sync-innerspace.respec
- *
- * Verifies SyncSagaCoordinator using InnerSpace (in-memory/local) spaces.
- * This avoids disk I/O issues and focuses on the synchronization logic.
- */
-
-import {
-    respecfully, lastOfAll, ifWe, iReckon,
-    ifWeMight
-} 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 { SyncSagaCoordinator } from './sync-saga-coordinator.mjs';
-import { putInSpace, 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 { createStoneHelper, createTimelineRootHelper, getTestKeystoneServiceHelper } from '../agent-helpers.mjs';
-import { mut8Timeline, appendToTimeline } from '../timeline/timeline-api.mjs';
-import { getDependencyGraph } from '../common/other/graph-helper.mjs';
-
-const logalot = true;
-const lc = `[sync-innerspace.respec]`;
-
-await respecfully(sir, `Sync InnerSpaces`, async () => {
-
-    let metaspace: Metaspace_Innerspace;
-    let sourceSpace: InnerSpace_V1;
-    let destSpace: InnerSpace_V1;
-
-    // Setup before each test? Or once?
-    // For now, let's just do it inside the test block to be safe/simple.
-
-    await ifWe(sir, `Basic Push Sync (Source -> Dest)`, async () => {
-        // 1. Setup Spaces
-        metaspace = new Metaspace_Innerspace(undefined);
-        await metaspace.initialize({
-            getFnAlert: () => async ({ title, msg }) => { console.log(`[Alert] ${title}: ${msg}`); },
-            getFnPrompt: () => async ({ title, msg }) => { console.log(`[Prompt] ${title}: ${msg}`); return ''; },
-            getFnPromptPassword: () => async (title, msg) => { console.log(`[PromptPwd] ${title}: ${msg}`); return null; },
-        });
-
-        // Create two distinct inner spaces manually or via metaspace if supported
-        // Metaspace_Innerspace typically manages one local user space, but we can instantiate InnerSpace_V1 directly.
-        sourceSpace = new InnerSpace_V1({ name: 'source', uuid: 'source_uuid' } as any);
-        await (sourceSpace as any).initialize();
-
-        destSpace = new InnerSpace_V1({ name: 'dest', uuid: 'dest_uuid' } as any);
-        await (destSpace as any).initialize();
-
-        // 2. Seed Source Data
-
-        // 2.1 Create a "Stone"
-        console.log(`${lc} Creating Stone...`);
-        const stone = await createStoneHelper({
-            ib: 'stone_data',
-            data: { some: 'data' },
-        });
-        const stoneAddr = getIbGibAddr({ ibGib: stone });
-        await putInSpace({ space: sourceSpace, ibGibs: [stone] });
-
-        // 2.2 Create a "Living" Timeline (Root)
-        console.log(`${lc} Creating Timeline Root...`);
-        const root = await createTimelineRootHelper({
-            ib: 'timeline_root',
-            data: { type: 'root', n: 0 },
-            space: sourceSpace,
-        });
-        const rootAddr = getIbGibAddr({ ibGib: root });
-
-        // 2.3 Evolve Timeline (Root -> Child)
-        // using mut8Timeline to simulate evolution
-        console.log(`${lc} Evolving Timeline...`);
-        const child = await mut8Timeline({
-            timeline: root,
-            mut8Opts: {
-                dataToAddOrPatch: { type: 'child', n: 1 }
-            },
-            metaspace,
-            space: sourceSpace,
-            // We use skipLock=true for simplicity in single-threaded test setup if locking is complex,
-            // but timeline-api handles locking. Let's try default first.
-            // Actually InnerSpace locking might be no-op or simple.
-        });
-        const childAddr = getIbGibAddr({ ibGib: child });
-
-        // 2.4 Rel8 Child to Stone (Dependency)
-        console.log(`${lc} Linking Child to Stone...`);
-        const childWithRel = await appendToTimeline({
-            timeline: child,
-            rel8nInfos: [{
-                rel8nName: 'linked_stone',
-                ibGibs: [stone]
-            }],
-            metaspace,
-            space: sourceSpace,
-        });
-        const childWithRelAddr = getIbGibAddr({ ibGib: childWithRel });
-
-        // 3. Setup Sync Coordinator
-        console.log(`${lc} Setting up Coordinator...`);
-        const mockKeystone = await getTestKeystoneServiceHelper();
-        const identity = await (mockKeystone as any).getIdentity();
-        const coordinator = new SyncSagaCoordinator(mockKeystone);
-
-        // 4. Run Sync
-        console.log(`${lc} Running Sync...`);
-        const syncRes = await coordinator.sync({
-            source: sourceSpace,
-            dest: destSpace,
-            domainIbGibs: [childWithRel], // Sync starting from the tip
-            identity
-        });
-
-        // 5. Verify Dest (Full Dependency Graph)
-        console.log(`${lc} Verifying Destination (Full Graph)...`);
-
-        // We expect the graph to contain: 
-        // 1. childWithRel
-        // 2. child (past of childWithRel)
-        // 3. root (ancestor of child, past of child)
-        // 4. stone (linked to childWithRel)
-        // 5. primitives (timeline_root, child, stone_data, identity, fork, mut8, rel8, root^gib, etc.)
-
-        // Let's get the graph from the source first to know what to expect (ground truth)
-        const sourceGraph = await getDependencyGraph({
-            ibGibs: [childWithRel],
-            space: sourceSpace,
-        });
-        const sourceAddrs = Object.keys(sourceGraph);
-        console.log(`${lc} Source Graph Size: ${sourceAddrs.length}`);
-
-        // Now get the graph from the destination
-        const destGraph = await getDependencyGraph({
-            ibGibs: [childWithRel],
-            space: destSpace,
-        });
-        const destAddrs = Object.keys(destGraph);
-        console.log(`${lc} Dest Graph Size: ${destAddrs.length}`);
-
-        // Assert
-        iReckon(sir, destAddrs.length).asTo('dest graph size').isGonnaBe(sourceAddrs.length);
-
-        for (const addr of sourceAddrs) {
-            const inDest = !!destGraph[addr];
-            if (!inDest) {
-                console.error(`${lc} Missing in dest: ${addr}`);
-            }
-            iReckon(sir, inDest).asTo(`addr present in dest: ${addr}`).isGonnaBeTrue();
-        }
-
-        console.log(`${lc} Verified Full Dependency Graph synced.`);
-    });
-
-    await ifWe(sir, `Idempotency (No-op if already synced)`, async () => {
-        // 1. Setup Spaces
-        const metaspace = new Metaspace_Innerspace(undefined);
-        await metaspace.initialize({
-            getFnAlert: () => async ({ title, msg }) => { console.log(`[Alert] ${title}: ${msg}`); },
-            getFnPrompt: () => async ({ title, msg }) => { console.log(`[Prompt] ${title}: ${msg}`); return ''; },
-            getFnPromptPassword: () => async (title, msg) => { console.log(`[PromptPwd] ${title}: ${msg}`); return null; },
-        });
-
-        const sourceSpace = new InnerSpace_V1({ name: 'source_idem', uuid: 'source_idem_uuid' } as any);
-        await (sourceSpace as any).initialize();
-
-        const destSpace = new InnerSpace_V1({ name: 'dest_idem', uuid: 'dest_idem_uuid' } as any);
-        await (destSpace as any).initialize();
-
-        // 2. Seed Source and Sync ONCE
-        const root = await createTimelineRootHelper({
-            ib: 'timeline_root',
-            data: { type: 'root', n: 0 },
-            space: sourceSpace,
-        });
-
-        const mockKeystone = await getTestKeystoneServiceHelper();
-        const identity = await (mockKeystone as any).getIdentity();
-        const coordinator = new SyncSagaCoordinator(mockKeystone);
-
-        console.log(`${lc} Running First Sync...`);
-        await coordinator.sync({
-            source: sourceSpace,
-            dest: destSpace,
-            domainIbGibs: [root],
-            identity
-        });
-
-        // Verify Initial State
-        const rootAddr = getIbGibAddr({ ibGib: root });
-        const getRoot1 = await getFromSpace({ space: destSpace, addr: rootAddr });
-        iReckon(sir, getRoot1.success).asTo('First Sync success').isGonnaBeTrue();
-
-        // 3. Run Sync AGAIN (Should be No-op)
-        console.log(`${lc} Running Second Sync...`);
-        await coordinator.sync({
-            source: sourceSpace,
-            dest: destSpace,
-            domainIbGibs: [root],
-            identity
-        });
-
-        // 4. Verify State Unchanged / Still Valid
-        const getRoot2 = await getFromSpace({ space: destSpace, addr: rootAddr });
-        iReckon(sir, getRoot2.success).asTo('Second Sync success').isGonnaBeTrue();
-
-        // Ensure no duplication or errors in destination (checking count in dependency graph might be good proxy?)
-        const destGraph = await getDependencyGraph({
-            ibGibs: [root],
-            space: destSpace,
-        });
-        iReckon(sir, Object.keys(destGraph).length).asTo('Dest Graph Size unchanged').isGonnaBe(Object.keys(destGraph).length); // Trivial assertion, mostly checking for no throw
-
-        console.log(`${lc} Verified Idempotency.`);
-    });
-
-    await ifWeMight(sir, `Dest Ahead (Pull/Fast-Backward)`, async () => {
-        // 1. Setup Spaces
-        const metaspace = new Metaspace_Innerspace(undefined);
-        await metaspace.initialize({
-            getFnAlert: () => async ({ title, msg }) => { console.log(`[Alert] ${title}: ${msg}`); },
-            getFnPrompt: () => async ({ title, msg }) => { console.log(`[Prompt] ${title}: ${msg}`); return ''; },
-            getFnPromptPassword: () => async (title, msg) => { console.log(`[PromptPwd] ${title}: ${msg}`); return null; },
-        });
-
-        const sourceSpace = new InnerSpace_V1({ name: 'source_pull', uuid: 'source_pull_uuid' } as any);
-        await (sourceSpace as any).initialize();
-
-        const destSpace = new InnerSpace_V1({ name: 'dest_pull', uuid: 'dest_pull_uuid' } as any);
-        await (destSpace as any).initialize();
-
-        // 2. Setup Initial Shared State
-        // Create root in Source, Sync to Dest
-        console.log(`${lc} Seeding initial shared state...`);
-        const root = await createTimelineRootHelper({
-            ib: 'timeline_pull',
-            data: { type: 'root', n: 0, state: 'initial' },
-            space: sourceSpace,
-        });
-        const rootAddr = getIbGibAddr({ ibGib: root });
-
-        const mockKeystone = await getTestKeystoneServiceHelper();
-        const identity = await (mockKeystone as any).getIdentity();
-        const coordinator = new SyncSagaCoordinator(mockKeystone);
-
-        await coordinator.sync({
-            source: sourceSpace,
-            dest: destSpace,
-            domainIbGibs: [root],
-            identity
-        });
-
-        // 3. Evolve DESTINATION (Simulate external update)
-        // We act "as if" we are on Dest side evolving it
-        console.log(`${lc} Evolving Destination (making Source behind)...`);
-        const childDest = await mut8Timeline({
-            timeline: root, // works because mut8Timeline just needs the ib/data/rel8ns/n, doesn't need to be "in" the space object-wise, but we persist to destSpace
-            mut8Opts: { dataToAddOrPatch: { n: 1, state: 'ahead' } },
-            metaspace,
-            space: destSpace,
-        });
-        const childDestAddr = getIbGibAddr({ ibGib: childDest });
-
-        // Verify Source DOES NOT have childDest
-        const getChildInSource = await getFromSpace({ space: sourceSpace, addr: childDestAddr });
-        iReckon(sir, getChildInSource.success).asTo('Source is behind').isGonnaBeFalse(); // Or success=true/addrsNotFound depending on impl
-
-        // 4. Run Sync from Source
-        // Checks:
-        // - Source should detect it is behind (or "conflict" in current generic terms).
-        // - Source should Pull 'childDest' from Dest.
-        // - Source should update itself.
-        console.log(`${lc} Running Sync (Pull)...`);
-        await coordinator.sync({
-            source: sourceSpace,
-            dest: destSpace,
-            domainIbGibs: [root], // We start with what Source knows (root)
-            identity
-        });
-
-        // 5. Verify Source Caught Up
-        const getChildInSourcePost = await getFromSpace({ space: sourceSpace, addr: childDestAddr });
-        iReckon(sir, getChildInSourcePost.success).asTo('Source pulled new frame').isGonnaBeTrue();
-        iReckon(sir, getChildInSourcePost.ibGibs?.[0]).asTo('Source has childDest').isGonnaBeTruthy();
-
-        console.log(`${lc} Verified Dest Ahead / Pull.`);
-    });
-});
+// /**
+//  * @module sync-innerspace.respec
+//  *
+//  * Verifies SyncSagaCoordinator using InnerSpace (in-memory/local) spaces.
+//  * This avoids disk I/O issues and focuses on the synchronization logic.
+//  */
+
+// import {
+//     respecfully, lastOfAll, ifWe, iReckon,
+//     ifWeMight
+// } from '@ibgib/helper-gib/dist/respec-gib/respec-gib.mjs';
+// const maam = `[${import.meta.url}]`, sir = maam;
+// import { pretty } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+// import { getIbGibAddr } from '@ibgib/ts-gib/dist/helper.mjs';
+// import { IbGibData_V1 } from '@ibgib/ts-gib/dist/V1/types.mjs';
+
+// import { SyncSagaCoordinator } from './sync-saga-coordinator.mjs';
+// import { putInSpace, 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 { createStoneHelper, createTimelineRootHelper, getTestKeystoneServiceHelper } from '../agent-helpers.mjs';
+// import { mut8Timeline, appendToTimeline, getLatestTimelineIbGibDto_nonLocking } from '../timeline/timeline-api.mjs';
+// import { getDependencyGraph } from '../common/other/graph-helper.mjs';
+// import { getTjpAddr } from '../common/other/ibgib-helper.mjs';
+// import { FlatIbGibGraph } from '../common/other/graph-types.mjs';
+// import { SyncConflictStrategy } from './sync-types.mjs';
+
+// const logalot = true;
+// const lc = `[sync-innerspace.respec]`;
+
+// /**
+//  * naive helper function to determine if two dependency graphs are equal.
+//  *
+//  * naive: only checks length of keys and if keys all match.
+//  *
+//  * @param a dependency graph from one space
+//  * @param b dep. graph from another space
+//  * @returns true if graphs are equal in size and keys, else false.
+//  */
+// function naiveGraphsAreEqual(a: FlatIbGibGraph, b: FlatIbGibGraph): boolean {
+//     const keysA = Object.keys(a);
+//     const keysB = Object.keys(b);
+//     if (keysA.length !== keysB.length) { false; }
+//     return keysA.every(key => !!b[key]);
+// }
+
+// await respecfully(sir, `Sync InnerSpaces`, async () => {
+
+//     let metaspace: Metaspace_Innerspace;
+//     let sourceSpace: InnerSpace_V1;
+//     let destSpace: InnerSpace_V1;
+
+//     // Setup before each test? Or once?
+//     // For now, let's just do it inside the test block to be safe/simple.
+
+//     await ifWeMight(sir, `Basic Push Sync (Source -> Dest)`, async () => {
+//         // 1. Setup Spaces
+//         metaspace = new Metaspace_Innerspace(undefined);
+//         await metaspace.initialize({
+//             getFnAlert: () => async ({ title, msg }) => { console.log(`[Alert] ${title}: ${msg}`); },
+//             getFnPrompt: () => async ({ title, msg }) => { console.log(`[Prompt] ${title}: ${msg}`); return ''; },
+//             getFnPromptPassword: () => async (title, msg) => { console.log(`[PromptPwd] ${title}: ${msg}`); return null; },
+//         });
+
+//         // Create two distinct inner spaces manually or via metaspace if supported
+//         // Metaspace_Innerspace typically manages one local user space, but we can instantiate InnerSpace_V1 directly.
+//         sourceSpace = new InnerSpace_V1({ name: 'source', uuid: 'source_uuid' } as any);
+//         await (sourceSpace as any).initialize();
+
+//         destSpace = new InnerSpace_V1({ name: 'dest', uuid: 'dest_uuid' } as any);
+//         await (destSpace as any).initialize();
+
+//         // 2. Seed Source Data
+
+//         // 2.1 Create a "Stone"
+//         console.log(`${lc} Creating Stone...`);
+//         const stone = await createStoneHelper({
+//             ib: 'stone_data',
+//             data: { some: 'data' },
+//         });
+//         const stoneAddr = getIbGibAddr({ ibGib: stone });
+//         await putInSpace({ space: sourceSpace, ibGibs: [stone] });
+
+//         // 2.2 Create a "Living" Timeline (Root)
+//         console.log(`${lc} Creating Timeline Root...`);
+//         const root = await createTimelineRootHelper({
+//             ib: 'timeline_root',
+//             data: { type: 'root', n: 0 },
+//             space: sourceSpace,
+//         });
+//         const rootAddr = getIbGibAddr({ ibGib: root });
+
+//         // 2.3 Evolve Timeline (Root -> Child)
+//         // using mut8Timeline to simulate evolution
+//         console.log(`${lc} Evolving Timeline...`);
+//         const child = await mut8Timeline({
+//             timeline: root,
+//             mut8Opts: {
+//                 dataToAddOrPatch: { type: 'child', n: 1 }
+//             },
+//             metaspace,
+//             space: sourceSpace,
+//             // We use skipLock=true for simplicity in single-threaded test setup if locking is complex,
+//             // but timeline-api handles locking. Let's try default first.
+//             // Actually InnerSpace locking might be no-op or simple.
+//         });
+//         const childAddr = getIbGibAddr({ ibGib: child });
+
+//         // 2.4 Rel8 Child to Stone (Dependency)
+//         console.log(`${lc} Linking Child to Stone...`);
+//         const childWithRel = await appendToTimeline({
+//             timeline: child,
+//             rel8nInfos: [{
+//                 rel8nName: 'linked_stone',
+//                 ibGibs: [stone]
+//             }],
+//             metaspace,
+//             space: sourceSpace,
+//         });
+//         const childWithRelAddr = getIbGibAddr({ ibGib: childWithRel });
+
+//         // 3. Setup Sync Coordinator
+//         console.log(`${lc} Setting up Coordinator...`);
+//         const mockKeystone = await getTestKeystoneServiceHelper();
+//         const identity = await (mockKeystone as any).getIdentity();
+//         const coordinator = new SyncSagaCoordinator(mockKeystone);
+
+//         // 4. Run Sync
+//         console.log(`${lc} Running Sync...`);
+//         const syncRes = await coordinator.sync({
+//             source: sourceSpace,
+//             dest: destSpace,
+//             domainIbGibs: [childWithRel], // Sync starting from the tip
+//             identity
+//         });
+
+//         // 5. Verify Dest (Full Dependency Graph)
+//         console.log(`${lc} Verifying Destination (Full Graph)...`);
+
+//         // We expect the graph to contain:
+//         // 1. childWithRel
+//         // 2. child (past of childWithRel)
+//         // 3. root (ancestor of child, past of child)
+//         // 4. stone (linked to childWithRel)
+//         // 5. primitives (timeline_root, child, stone_data, identity, fork, mut8, rel8, root^gib, etc.)
+
+//         // Let's get the graph from the source first to know what to expect (ground truth)
+//         const sourceGraph = await getDependencyGraph({
+//             ibGibs: [childWithRel],
+//             space: sourceSpace,
+//         });
+//         const sourceAddrs = Object.keys(sourceGraph);
+//         console.log(`${lc} Source Graph Size: ${sourceAddrs.length}`);
+
+//         // Now get the graph from the destination
+//         const destGraph = await getDependencyGraph({
+//             ibGibs: [childWithRel],
+//             space: destSpace,
+//         });
+//         const destAddrs = Object.keys(destGraph);
+//         console.log(`${lc} Dest Graph Size: ${destAddrs.length}`);
+
+//         // Assert
+//         iReckon(sir, destAddrs.length).asTo('dest graph size').isGonnaBe(sourceAddrs.length);
+
+//         for (const addr of sourceAddrs) {
+//             const inDest = !!destGraph[addr];
+//             if (!inDest) {
+//                 console.error(`${lc} Missing in dest: ${addr}`);
+//             }
+//             iReckon(sir, inDest).asTo(`addr present in dest: ${addr}`).isGonnaBeTrue();
+//         }
+
+//         console.log(`${lc} Verified Full Dependency Graph synced.`);
+//     });
+
+//     await ifWeMight(sir, `Idempotency (No-op if already synced)`, async () => {
+//         // 1. Setup Spaces
+//         const metaspace = new Metaspace_Innerspace(undefined);
+//         await metaspace.initialize({
+//             getFnAlert: () => async ({ title, msg }) => { console.log(`[Alert] ${title}: ${msg}`); },
+//             getFnPrompt: () => async ({ title, msg }) => { console.log(`[Prompt] ${title}: ${msg}`); return ''; },
+//             getFnPromptPassword: () => async (title, msg) => { console.log(`[PromptPwd] ${title}: ${msg}`); return null; },
+//         });
+
+//         const sourceSpace = new InnerSpace_V1({ name: 'source_idem', uuid: 'source_idem_uuid' } as any);
+//         await (sourceSpace as any).initialize();
+
+//         const destSpace = new InnerSpace_V1({ name: 'dest_idem', uuid: 'dest_idem_uuid' } as any);
+//         await (destSpace as any).initialize();
+
+//         // 2. Seed Source and Sync ONCE
+//         const root = await createTimelineRootHelper({
+//             ib: 'timeline_root',
+//             data: { type: 'root', n: 0 },
+//             space: sourceSpace,
+//         });
+
+//         const mockKeystone = await getTestKeystoneServiceHelper();
+//         const identity = await (mockKeystone as any).getIdentity();
+//         const coordinator = new SyncSagaCoordinator(mockKeystone);
+
+//         console.log(`${lc} Running First Sync...`);
+//         await coordinator.sync({
+//             source: sourceSpace,
+//             dest: destSpace,
+//             domainIbGibs: [root],
+//             identity
+//         });
+
+//         // Verify Initial State
+//         const rootAddr = getIbGibAddr({ ibGib: root });
+//         const getRoot1 = await getFromSpace({ space: destSpace, addr: rootAddr });
+//         iReckon(sir, getRoot1.success).asTo('First Sync success').isGonnaBeTrue();
+
+//         // 3. Run Sync AGAIN (Should be No-op)
+//         console.log(`${lc} Running Second Sync...`);
+//         await coordinator.sync({
+//             source: sourceSpace,
+//             dest: destSpace,
+//             domainIbGibs: [root],
+//             identity
+//         });
+
+//         // 4. Verify State Unchanged / Still Valid
+//         const getRoot2 = await getFromSpace({ space: destSpace, addr: rootAddr });
+//         iReckon(sir, getRoot2.success).asTo('Second Sync success').isGonnaBeTrue();
+
+//         // Ensure no duplication or errors in destination (checking count in dependency graph might be good proxy?)
+//         const destGraph = await getDependencyGraph({
+//             ibGibs: [root],
+//             space: destSpace,
+//         });
+//         iReckon(sir, Object.keys(destGraph).length).asTo('Dest Graph Size unchanged').isGonnaBe(Object.keys(destGraph).length); // Trivial assertion, mostly checking for no throw
+
+//         console.log(`${lc} Verified Idempotency.`);
+//     });
+
+//     await ifWeMight(sir, `Dest Ahead (Pull/Fast-Backward)`, async () => {
+//         // 1. Setup Spaces
+//         // Metaspace_Innerspace automatically initializes spaces so we don't need manual initialize calls for these if they were standard.
+//         // But here we are instantiating them directly.
+//         // User pointed out initialize is called in constructor.
+//         const metaspace = new Metaspace_Innerspace(undefined);
+//         await metaspace.initialize({
+//             getFnAlert: () => async ({ title, msg }) => { console.log(`[Alert] ${title}: ${msg}`); },
+//             getFnPrompt: () => async ({ title, msg }) => { console.log(`[Prompt] ${title}: ${msg}`); return ''; },
+//             getFnPromptPassword: () => async (title, msg) => { console.log(`[PromptPwd] ${title}: ${msg}`); return null; },
+//         });
+
+//         // const sourceSpace = new InnerSpace_V1({ name: 'source_pull', uuid: 'source_pull_uuid' } as any);
+//         const sourceSpace = new InnerSpace_V1({ name: 'source_pull', } as any);
+//         // await (sourceSpace as any).initialize(); // Already initialized in ctor
+
+//         // const destSpace = new InnerSpace_V1({ name: 'dest_pull', uuid: 'dest_pull_uuid' } as any);
+//         const destSpace = new InnerSpace_V1({ name: 'dest_pull', } as any);
+//         // await (destSpace as any).initialize(); // Already initialized in ctor
+
+//         // 2. Setup Initial Shared State
+//         // Create root in Source, Sync to Dest
+//         console.log(`${lc} Seeding initial shared state...`);
+//         const root = await createTimelineRootHelper({
+//             ib: 'timeline_pull',
+//             data: { type: 'root', state: 'initial' },
+//             space: sourceSpace,
+//         });
+//         const rootAddr = getIbGibAddr({ ibGib: root });
+//         if (logalot) { console.log(`${lc} rootAddr: ${rootAddr} (I: 486bcba15f0a3307f8e6aa88089d1825)`); }
+//         const tjpAddr = getTjpAddr({ ibGib: root, defaultIfNone: 'incomingAddr' }) || rootAddr; // Root is typically its own TJP if not explicit
+//         if (logalot) { console.log(`${lc} tjpAddr: ${tjpAddr} (I: b9326dfb66b8efe8a829673335869c25)`); }
+//         if (logalot) { console.log(`${lc} root:\n${pretty(root)} (I: 3051584310780a36c8435d7881d2f825)`); }
+
+//         const mockKeystone = await getTestKeystoneServiceHelper();
+//         const identity = await (mockKeystone as any).getIdentity();
+//         const coordinator = new SyncSagaCoordinator(mockKeystone);
+
+//         await coordinator.sync({
+//             source: sourceSpace,
+//             dest: destSpace,
+//             domainIbGibs: [root],
+//             identity
+//         });
+
+//         let rootGraph_source: FlatIbGibGraph = await getDependencyGraph({ ibGib: root, space: sourceSpace });
+//         let rootGraph_dest: FlatIbGibGraph = await getDependencyGraph({ ibGib: root, space: destSpace });
+//         let rootsSynced = naiveGraphsAreEqual(rootGraph_source, rootGraph_dest);
+//         if (rootsSynced) {
+//             if (logalot) { console.log(`${lc} rootsSynced (I: 493982dbc9f40170fd26a0d8e0b69825)`); }
+//         } else {
+//             throw new Error(`(UNEXPECTED) graphs are not equal after simple root push sync? (E: f10be8a3d285f260989419c8b99bc225)`);
+//         }
+
+//         // 3. Evolve DESTINATION (Simulate external update)
+//         // We act "as if" we are on Dest side evolving it. This is like we are
+//         // syncing with the remote, and there were changes created by someone
+//         // else but we have no local changes.
+//         console.log(`${lc} Evolving Destination (making Source behind)...`);
+//         const childDest = await mut8Timeline({
+//             timeline: root, // works because mut8Timeline just needs the ib/data/rel8ns/n, doesn't need to be "in" the space object-wise, but we persist to destSpace
+//             mut8Opts: { dataToAddOrPatch: { type: 'modified in dest', state: 'ahead' } },
+//             metaspace,
+//             space: destSpace,
+//         });
+//         const childDestAddr = getIbGibAddr({ ibGib: childDest });
+//         if (logalot) { console.log(`${lc} childDest:\n${pretty(childDest)}(I: ff4868842d8757df98cfe59ec5bea825)`); }
+
+//         // Log debugging info for TJP
+//         const childDestTjpAddr = getTjpAddr({ ibGib: childDest });
+//         console.log(`${lc} childDestAddr: ${childDestAddr}`);
+//         console.log(`${lc} rootAddr (Expected TJP?): ${rootAddr}`);
+//         console.log(`${lc} childDest TJP Addr: ${childDestTjpAddr}`);
+
+//         // If TJP is missing or mismatched, that's why getLatestAddrs fails
+//         if (!childDestTjpAddr || childDestTjpAddr !== tjpAddr) {
+//             // NOTE: THIS DOES NOT HIT
+//             console.warn(`${lc} WARNING: childDest TJP (${childDestTjpAddr}) does not match root/expected TJP (${tjpAddr}). This likely causes sync to miss it.`);
+//             // Hack fix for test verification if mut8Timeline is slightly broken on TJP propagation for raw tests
+//             if (!childDest.rel8ns) { childDest.rel8ns = {}; }
+//             childDest.rel8ns.tjp = [tjpAddr];
+//             // Re-put to update index?? No, InnerSpace uses in-memory map references often if we modified object.
+//             // Better to re-put explicitly if we modified it.
+//             await putInSpace({ space: destSpace, ibGibs: [childDest] });
+//         }
+
+//         console.log(`${lc} sourceSpace UUID: ${(sourceSpace as any).data.uuid}`);
+//         console.log(`${lc} destSpace UUID: ${(destSpace as any).data.uuid}`);
+
+//         // Verify Source DOES NOT have childDest
+//         const getChildInSource = await getFromSpace({ space: sourceSpace, addr: childDestAddr });
+//         iReckon(sir, getChildInSource.success).asTo('Source is behind').isGonnaBeFalse(); // Or success=true/addrsNotFound depending on impl
+
+//         // 4. Run Sync from Source
+//         // Checks:
+//         // - Source should detect it is behind (or "conflict" in current generic terms).
+//         // - Source should Pull 'childDest' from Dest.
+//         // - Source should update itself.
+//         console.log(`${lc} Running Sync (Pull)...`);
+//         await coordinator.sync({
+//             source: sourceSpace,
+//             dest: destSpace,
+//             domainIbGibs: [root], // We start with what Source knows (root)
+//             identity
+//         });
+
+//         // 5. Verify Source Caught Up
+//         const getChildInSourcePost = await getFromSpace({ space: sourceSpace, addr: childDestAddr });
+//         console.log(`${lc} getChildInSourcePost success: ${getChildInSourcePost.success}`);
+//         if (getChildInSourcePost.ibGibs) {
+//             console.log(`${lc} getChildInSourcePost found: ${getChildInSourcePost.ibGibs.length} ibGibs`);
+//         } else {
+//             console.log(`${lc} getChildInSourcePost found: 0 ibGibs (undefined)`);
+//         }
+
+//         iReckon(sir, getChildInSourcePost.success).asTo('Source pulled new frame').isGonnaBeTrue();
+//         iReckon(sir, getChildInSourcePost.ibGibs?.[0]).asTo('Source has childDest').isGonnaBeTruthy();
+
+//         console.log(`${lc} Verified Dest Ahead / Pull.`);
+//     });
+
+//     await ifWeMight(sir, `Divergent (Conflict Detection)`, async () => {
+//         interface TestData extends IbGibData_V1 {
+//             type: string;
+//             state?: string;
+//             branch?: string;
+//         }
+
+//         // 1. Setup
+//         const metaspace = new Metaspace_Innerspace(undefined);
+//         await metaspace.initialize({
+//             getFnAlert: () => async ({ title, msg }) => { console.log(`[Alert] ${title}: ${msg}`); },
+//             getFnPrompt: () => async ({ title, msg }) => { console.log(`[Prompt] ${title}: ${msg}`); return ''; },
+//             getFnPromptPassword: () => async (title, msg) => { console.log(`[PromptPwd] ${title}: ${msg}`); return null; },
+//         });
+
+//         const sourceSpace = new InnerSpace_V1({ name: 'source_div', uuid: 'source_div_uuid' } as any);
+//         // await (sourceSpace as any).initialize();
+//         const destSpace = new InnerSpace_V1({ name: 'dest_div', uuid: 'dest_div_uuid' } as any);
+//         // await (destSpace as any).initialize();
+
+//         // 2. Setup Shared Root
+//         const root = await createTimelineRootHelper<TestData>({
+//             ib: 'timeline_div',
+//             data: { type: 'root' },
+//             space: sourceSpace,
+//         });
+//         const rootAddr = getIbGibAddr({ ibGib: root });
+//         const tjpAddr = getTjpAddr({ ibGib: root }) || rootAddr;
+
+//         // Sync root to dest so they share base
+//         await putInSpace({ space: destSpace, ibGibs: [root] });
+//         // NOTE: Must manually index TJP in dest if putInSpace doesn't trigger full indexing (InnerSpace might need register)
+//         // Ideally we run a sync to init, but manual put + hack fix is faster for setup.
+//         // Actually, let's use coordinator to sync root first to ensure clean state.
+//         const mockKeystone = await getTestKeystoneServiceHelper();
+//         const identity = await (mockKeystone as any).getIdentity();
+//         const coordinator = new SyncSagaCoordinator(mockKeystone);
+
+//         await coordinator.sync({
+//             source: sourceSpace,
+//             dest: destSpace,
+//             domainIbGibs: [root],
+//             identity
+//         });
+
+//         // 3. Diverge!
+//         // Source creates Child A
+//         const childA = await mut8Timeline({
+//             timeline: root,
+//             mut8Opts: { dataToAddOrPatch: { branch: 'A' } },
+//             metaspace,
+//             space: sourceSpace,
+//         });
+//         const childAAddr = getIbGibAddr({ ibGib: childA });
+
+//         // Dest (simulated) creates Child B from Root (Forking history)
+//         const childB = await mut8Timeline({
+//             timeline: root,
+//             mut8Opts: { dataToAddOrPatch: { branch: 'B' } }, // Logic: same n=1, but different content/hash
+//             metaspace,
+//             space: destSpace,
+//         });
+//         const childBAddr = getIbGibAddr({ ibGib: childB });
+
+//         // Ensure TJP indexing on Dest (test hack)
+//         const childBTjp = getTjpAddr({ ibGib: childB });
+//         if (!childBTjp || childBTjp !== tjpAddr) {
+//             if (!childB.rel8ns) childB.rel8ns = {};
+//             childB.rel8ns.tjp = [tjpAddr];
+//             await putInSpace({ space: destSpace, ibGibs: [childB] });
+//         }
+
+//         console.log(`${lc} Divergence Setup:`);
+//         console.log(`${lc}   Root: ${rootAddr}`);
+//         console.log(`${lc}   Source Tip (A): ${childAAddr}`);
+//         console.log(`${lc}   Dest Tip (B):   ${childBAddr}`);
+
+//         // 4. Sync with Strategy: 'abort' (Expect Error)
+//         console.log(`${lc} Running Sync (Abort Strategy)...`);
+//         let caughtError;
+//         try {
+//             await coordinator.sync({
+//                 source: sourceSpace,
+//                 dest: destSpace,
+//                 domainIbGibs: [childA],
+//                 identity,
+//                 conflictStrategy: SyncConflictStrategy.abort, // Should throw
+//             });
+//         } catch (e) {
+//             caughtError = e;
+//             console.log(`${lc} Caught expected error: ${e.message}`);
+//         }
+//         iReckon(sir, caughtError).asTo('Should throw on conflict with abort strategy').isGonnaBeTruthy();
+
+//         // 5. Sync with Strategy: 'optimistic' (Expect Merge)
+//         // TODO: Implement optimistic merging
+//     });
+
+// });