@ibgib/core-gib 0.1.13 → 0.1.15

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

@@ -2,7 +2,7 @@
  * @module sync-innerspace.respec
  *
  * Verifies SyncSagaCoordinator using InnerSpace (in-memory/local) spaces.
- * This avoids disk I/O issues and focuses on the synchronization logic.
+ * This utilizes SyncPeerInnerspace_V1 for local-to-local synchronization simulations.
  */
 
 import {
@@ -12,446 +12,99 @@ import {
 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 { mut8Timeline, appendToTimeline } 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 { SyncPeerInnerspace_V1 } from './sync-peer/sync-peer-innerspace-v1.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 () => {
+    await ifWeMight(sir, `Basic Push Sync (Source -> Dest)`, 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);
+        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
+        sourceSpace = new InnerSpace_V1({ name: 'source', uuid: 'source_uuid' } as any);
+        await (sourceSpace as any).initialize();
 
-        // 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
+        destSpace = new InnerSpace_V1({ name: 'dest', uuid: 'dest_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...`);
+        // 2. Seed Source Data
+        console.log(`${lc} Creating data in Source...`);
         const root = await createTimelineRootHelper({
-            ib: 'timeline_pull',
-            data: { type: 'root', state: 'initial' },
+            ib: 'timeline_root',
+            data: { type: 'root', n: 0 },
             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' } },
+        const child = await mut8Timeline({
+            timeline: root,
+            mut8Opts: {
+                dataToAddOrPatch: { type: 'child', n: 1 }
+            },
             metaspace,
-            space: destSpace,
+            space: sourceSpace,
         });
-        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}`);
+        const childAddr = getIbGibAddr({ ibGib: child });
 
-        // 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}`);
+        // 3. Setup Coordinators & Peer
+        console.log(`${lc} Setting up Coordinators...`);
+        const mockKeystone = await getTestKeystoneServiceHelper();
+        const identity = await (mockKeystone as any).getIdentity();
 
-        // 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
+        // Sender Coordinator 
+        const senderCoordinator = new SyncSagaCoordinator(mockKeystone);
+
+        // Receiver Coordinator
+        // Note: Receiver acts "globally" usually, but here we treat it as bound to the dest operations?
+        // Actually SyncSagaCoordinator isn't bound to a space. It works ON a space.
+        // So we can reuse or create separate instances. Let's create separate to simulate remote.
+        const receiverCoordinator = new SyncSagaCoordinator(mockKeystone);
+
+        // Peer (The "Network")
+        const peer = new SyncPeerInnerspace_V1({
+            senderSpace: sourceSpace,   // "Client"
+            receiverSpace: destSpace,   // "Server"
+            receiverCoordinator: receiverCoordinator,
+            receiverMetaspace: metaspace,
+        });
 
-        // 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)
+        // 4. Run Sync
+        console.log(`${lc} Running Sync...`);
+        const syncRes = await senderCoordinator.sync({
+            peer: peer,
+            localSpace: sourceSpace,
+            targetSpace: undefined, // Not used when peer is provided
+            metaspace: metaspace,
+            domainIbGibs: [child], // Sync the child
             identity
-        });
+        } as any); // Type cast if needed until we align optional params
 
-        // 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)`);
-        }
+        // 5. Verify Dest
+        console.log(`${lc} Verifying Destination...`);
+        const getChildInDest = await getFromSpace({ space: destSpace, addr: childAddr });
 
-        iReckon(sir, getChildInSourcePost.success).asTo('Source pulled new frame').isGonnaBeTrue();
-        iReckon(sir, getChildInSourcePost.ibGibs?.[0]).asTo('Source has childDest').isGonnaBeTruthy();
+        iReckon(sir, getChildInDest.success).asTo('Child present in Dest').isGonnaBeTrue();
+        iReckon(sir, getChildInDest.ibGibs?.[0]?.data?.n).asTo('Child content matches').isGonnaBe(1);
 
-        console.log(`${lc} Verified Dest Ahead / Pull.`);
+        console.log(`${lc} Verified Basic Push.`);
     });
 
-    // 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: '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
-    // });
-
 });

package/src/sync/sync-peer/sync-peer-innerspace-v1.mts

@@ -0,0 +1,150 @@
+/**
+ * @module SyncPeerInnerspace_V1
+ */
+
+import { IbGib_V1 } from '@ibgib/ts-gib/dist/V1/types.mjs';
+import { getIbGibAddr } from '@ibgib/ts-gib/dist/helper.mjs';
+import { IbGibSpaceAny } from '../../witness/space/space-base-v1.mjs';
+import { SyncSagaContextIbGib_V1 } from '../sync-saga-context/sync-saga-context-types.mjs';
+import { SyncPeer_V1 } from './sync-peer-v1.mjs';
+import { SyncSagaCoordinator } from '../sync-saga-coordinator.mjs';
+import { createSyncSagaContext } from '../sync-saga-context/sync-saga-context-helpers.mjs';
+import { getFromSpace, putInSpace } from '../../witness/space/space-helper.mjs';
+import { getDependencyGraph } from '../../witness/space/space-helper.mjs';
+import { MetaspaceService } from '../../witness/space/metaspace/metaspace-types.mjs';
+
+export interface SyncPeerInnerspaceOptions {
+    senderSpace: IbGibSpaceAny;
+    receiverSpace: IbGibSpaceAny;
+    receiverCoordinator: SyncSagaCoordinator;
+    receiverMetaspace: MetaspaceService; // Need this for receiver execution
+}
+
+/**
+ * Concrete implementation of SyncPeer for local in-memory simulation (Innerspace to Innerspace).
+ * 
+ * Acts as the "Network" layer, transferring data between two local spaces and 
+ * executing the receiver's coordinator logic.
+ */
+export class SyncPeerInnerspace_V1 extends SyncPeer_V1 {
+
+    protected lc: string = `[${SyncPeerInnerspace_V1.name}]`;
+
+    constructor(
+        public opts: SyncPeerInnerspaceOptions
+    ) {
+        super(opts.receiverSpace.data!); // Use receiver space data as initial phantom data? Or empty.
+    }
+
+    /**
+     * Simulates the network transmission and receiver execution.
+     */
+    async witness(arg: SyncSagaContextIbGib_V1): Promise<SyncSagaContextIbGib_V1 | undefined> {
+        const lc = `${this.lc}[${this.witness.name}]`;
+        const { senderSpace, receiverSpace, receiverCoordinator, receiverMetaspace } = this.opts;
+
+        // 1. "Receive" Request (Transfer from Sender -> Receiver)
+        const sagaFrameAddr = arg.rel8ns?.sagaFrame?.[0];
+        if (!sagaFrameAddr) { throw new Error(`${lc} Missing sagaFrame in context (E: a1b2c3d4e5)`); }
+
+        // Get Saga Frame (Sender internal -> Receiver internal)
+        await this.transfer({ addr: sagaFrameAddr, from: senderSpace, to: receiverSpace });
+        const sagaFrame = (await getFromSpace({ addr: sagaFrameAddr, space: receiverSpace })).ibGibs?.[0] as any; // Cast for now
+
+        // Get Payload (Sender internal -> Receiver internal)
+        const payloadAddrs = arg.rel8ns?.payloadAddrs || [];
+        if (payloadAddrs.length > 0) {
+            await this.transfer({ addrs: payloadAddrs, from: senderSpace, to: receiverSpace });
+        }
+
+        // 2. Prepare Receiver Execution
+        // We need a srcGraph for the Receiver if it needs to send data (e.g. Ack/Push).
+        // Since we are stateless here (simulating a request), we rebuild the graph context ???
+        // Or we pass a lazy getter? For now, let's load what we can or pass empty if not needed.
+        // Actually, for Init/delta handling, we might not need the FULL graph if we use space lookups.
+        // But let's look at `handleSagaFrame` requirements.
+
+        let srcGraph: { [addr: string]: IbGib_V1 } = {};
+        // Optimally we wouldn't scan the whole space every request. But for testing:
+        // const allGraph = await getDependencyGraph({ space: receiverSpace, ... }); 
+        // TOO SLOW.
+        // Let's pass an empty graph initially and assume `handleSagaFrame` relies on Space helpers where possible?
+        // `SyncSagaCoordinator.analyzeTimelines` generates the graph.
+        // `handleAckFrame` uses `srcGraph` to fulfill requests.
+        // If we are mostly testing Init -> Ack (Empty) -> Delta (Receive), we might survive without it.
+        // But if Receiver acts as Sender...
+
+        // 3. Execute Receiver Logic
+        const result = await receiverCoordinator.handleSagaFrame({
+            sagaIbGib: sagaFrame,
+            srcGraph: srcGraph, // Empty for now, may fail if push needed
+            space: receiverSpace,
+            metaspace: receiverMetaspace,
+            // Identity? Receiver needs its own identity?
+            // If receiverCoordinator is initialized with an identity, or we pass one here?
+            // `sync()` does `getSessionIdentity`. Here we might need to mock/provide one.
+            // For now, undefined (anonymous sync) or we add to opts.
+        });
+
+        if (!result) {
+            // Null result means saga complete on receiver side? Or no response?
+            return undefined;
+        }
+
+        const responseFrame = result.frame;
+        const responsePayload = result.payloadIbGibs || [];
+
+        // 4. "Send" Response (Transfer from Receiver -> Sender)
+        const responseFrameAddr = getIbGibAddr({ ibGib: responseFrame });
+        await putInSpace({ space: receiverSpace, ibGib: responseFrame }); // Ensure it's saved in Receiver
+        await this.transfer({ addr: responseFrameAddr, from: receiverSpace, to: senderSpace });
+
+        const responsePayloadAddrs: string[] = [];
+        if (responsePayload.length > 0) {
+            await putInSpace({ space: receiverSpace, ibGibs: responsePayload });
+            for (const p of responsePayload) {
+                const addr = getIbGibAddr({ ibGib: p });
+                responsePayloadAddrs.push(addr);
+                await this.transfer({ addr, from: receiverSpace, to: senderSpace });
+            }
+        }
+
+        // 5. Create Response Context
+        const responseCtx = await createSyncSagaContext({
+            sagaFrame: responseFrame,
+            payloadAddrs: responsePayloadAddrs.length > 0 ? responsePayloadAddrs : undefined,
+            // TODO: identity/claims
+        });
+
+        // Ensure Context is in Sender Space (Network delivery)
+        await putInSpace({ space: senderSpace, ibGib: responseCtx });
+
+        return responseCtx;
+    }
+
+    /**
+     * Helper to copy ibgibs from A to B.
+     */
+    protected async transfer({
+        addr,
+        addrs,
+        from,
+        to
+    }: {
+        addr?: string,
+        addrs?: string[],
+        from: IbGibSpaceAny,
+        to: IbGibSpaceAny
+    }): Promise<void> {
+        const targets = addrs || (addr ? [addr] : []);
+        if (targets.length === 0) return;
+
+        // Naive infinite dependency transfer or just shallow?
+        // Sync usually implies sending dependencies.
+        // `getDependencyGraph` from `from` space using these roots.
+        const graph = await getDependencyGraph({ space: from, ibGibAddrs: targets });
+        if (graph) {
+            await putInSpace({ space: to, ibGibs: Object.values(graph) });
+        }
+    }
+}