@ibgib/core-gib 0.1.12 → 0.1.13

package/src/sync/sync-saga-coordinator.mts

@@ -2,7 +2,9 @@ import {
     extractErrorMsg,
     getUUID, // so our uuid's are uniform across all ibgib code
     getTimestamp, // so our timestamp strings are uniform
-    getTimestampInTicks // so our timestamp in ticks as a string are uniform
+    getTimestampInTicks, // so our timestamp in ticks as a string are uniform
+    pretty,
+    clone
 } from "@ibgib/helper-gib/dist/helpers/utils-helper.mjs";
 import { getIbGibAddr } from "@ibgib/ts-gib/dist/helper.mjs";
 import { splitPerTjpAndOrDna, getTimelinesGroupedByTjp } from "../common/other/ibgib-helper.mjs";
@@ -12,7 +14,7 @@ import { isPrimitive } from "@ibgib/ts-gib/dist/V1/transforms/transform-helper.m
 
 import { GLOBAL_LOG_A_LOT } from "../core-constants.mjs";
 import { IbGibSpaceAny } from "../witness/space/space-base-v1.mjs";
-import { putInSpace, lockSpace, unlockSpace, getSpaceArgMetadata, getLatestAddrs } from "../witness/space/space-helper.mjs";
+import { putInSpace, lockSpace, unlockSpace, getSpaceArgMetadata, getLatestAddrs, getFromSpace } from "../witness/space/space-helper.mjs";
 import { KeystoneIbGib_V1 } from "../keystone/keystone-types.mjs";
 import { KeystoneService_V1 } from "../keystone/keystone-service-v1.mjs";
 import { SyncStage, SYNC_ATOM } from "./sync-constants.mjs";
@@ -22,7 +24,7 @@ import {
 import { getSyncIb } from "./sync-helpers.mjs";
 import { getDependencyGraph } from "../common/other/graph-helper.mjs";
 
-const logalot = GLOBAL_LOG_A_LOT;
+const logalot = GLOBAL_LOG_A_LOT || true;
 
 export interface SyncOptions {
     /**
@@ -41,8 +43,19 @@ export interface SyncOptions {
      * The secret for the identity (to sign the commit).
      */
     identitySecret: string;
+    /**
+     * How to handle conflicts when both Source and Dest have diverged on the same timeline.
+     * @default 'abort'
+     */
+    conflictStrategy?: SyncConflictStrategy;
 }
 
+export type SyncConflictStrategy =
+    | 'abort'      // Throw error on divergence
+    | 'optimistic' // Attempt to merge (e.g. valid if CRDT/DAG based)
+    | 'manual';    // (Future) Store conflict and defer
+
+
 /**
  * Orchestrates the synchronization process between two spaces (Source and Destination).
  *
@@ -122,13 +135,15 @@ export class SyncSagaCoordinator {
         dest,
         identity,
         domainIbGibs,
-        identitySecret
+        identitySecret,
+        conflictStrategy
     }: {
         source: IbGibSpaceAny,
         dest: IbGibSpaceAny,
         identity: KeystoneIbGib_V1,
         domainIbGibs: IbGib_V1[],
         identitySecret?: string,
+        conflictStrategy?: SyncConflictStrategy,
     }): Promise<void> {
         const lc = `${this.lc}[${this.sync.name}]`;
         try {
@@ -145,136 +160,60 @@ export class SyncSagaCoordinator {
             // ---------------------------------------------------------
             // 1. Graph Generation & Classification
             // ---------------------------------------------------------
-            // We want a live dependency graph to ensure we get the latest
-            // states of timelines.
-            const graph = await getDependencyGraph({
-                ibGibs: domainIbGibs,
-                live: true,
-                space: source,
+            const { srcStones, srcTimelinesMap, srcSortedTjps, srcGraph } = await this.analyzeTimelines({
+                domainIbGibs,
+                space: source
             });
-            const validGraph = graph && Object.keys(graph).length > 0;
-            if (logalot) { console.log(`${lc} graph generated. nodes: ${validGraph ? Object.keys(graph).length : 0}`); }
-
-            // 2. Classification
-            // We differentiate between "Stones" (Immutable, no timeline) and "Living" (Timelines).
-            // Stones can be synced in bulk without ordering.
-            // Living ibGibs must be grouped by timeline and ordered.
-            const ibGibs = validGraph ? Object.values(graph) : [];
-            const { mapWithTjp_YesDna, mapWithTjp_NoDna, mapWithoutTjps } = splitPerTjpAndOrDna({ ibGibs });
-
-            // "Stones" come from mapWithoutTjps
-            const stones = Object.values(mapWithoutTjps);
-
-            // "Living" come from both TJP maps
-            // We combine them to group by TJP
-            const living = [...Object.values(mapWithTjp_YesDna), ...Object.values(mapWithTjp_NoDna)];
-
-            if (logalot) {
-                console.log(`${lc} classification results (count):`);
-                console.log(`stones: ${stones.length}`);
-                console.log(`living: ${living.length}`);
-            }
 
-            // 3. Timeline Ordering
-            // Group living ibGibs by TJP to identify distinct timelines.
-            // The helper returns them sorted by 'n' ascending.
-            const timelinesMap = getTimelinesGroupedByTjp({ ibGibs: living });
-
-            // todo: perform topological sort on timelinesMap based on inter-timeline references.
-            // For now, we sync independent timelines.
-
-            const payloadAddrs: string[] = [];
-            payloadAddrs.push(...stones.map(x => getIbGibAddr({ ibGib: x })));
-            // 3. Timeline Ordering (Topological Sort)
-            // Living ibGibs are grouped by timeline (TJP).
-            // We need to order these timelines based on dependencies.
-            const sortedTjps = this.sortTimelinesTopologically(timelinesMap);
-
-            // Add ordered timelines to payload
-            sortedTjps.forEach(tjp => {
-                const timeline = timelinesMap[tjp];
-                payloadAddrs.push(...timeline.map(x => getIbGibAddr({ ibGib: x })));
-            });
-
-            // 2. INIT & Phase 2: Knowledge Exchange
+            // ---------------------------------------------------------
+            // 2. Knowledge Exchange (Init) & 3. Conflict Resolution
+            // ---------------------------------------------------------
+            // Phase 1: Init Data
             const srcKnowledgeVector: { [tjp: string]: string } = {};
-            Object.keys(timelinesMap).forEach(tjp => {
-                const timeline = timelinesMap[tjp];
-                const tip = timeline[timeline.length - 1];
+            Object.keys(srcTimelinesMap).forEach(tjp => {
+                const timeline = srcTimelinesMap[tjp];
+                const tip = timeline.at(-1)!;
                 srcKnowledgeVector[tjp] = getIbGibAddr({ ibGib: tip });
             });
 
+            // Need to determine mode correctly. Just defaulting to push for now
+            // as per original impl instructions (or TODO)
             const initData: SyncInitData = {
                 knowledgeVector: srcKnowledgeVector,
                 identity: identity,
                 mode: 'push'
             };
 
-            // Get Source Knowledge (Time -> Latest)
-            const srcTjps = Object.keys(timelinesMap);
-            // Get Dest Knowledge
-            const destKnowledge = await this.getLatestAddrsFromSpace({ space: dest, tjpAddrs: srcTjps });
-
-            const conflicts: string[] = [];
-            for (const tjp of srcTjps) {
-                const srcTimeline = timelinesMap[tjp];
-                const srcTip = srcTimeline[srcTimeline.length - 1];
-                const srcTipAddr = getIbGibAddr({ ibGib: srcTip });
-                const destTipAddr = destKnowledge[tjp];
-
-                if (destTipAddr && destTipAddr !== srcTipAddr) {
-                    // Divergence found. Check if Source knows Dest's tip.
-                    if (graph[destTipAddr]) {
-                        // Fast-Forward: Dest tip IS in our graph, so we are ahead.
-                        // No action needed, proceed to push.
-                    } else {
-                        // Conflict: Dest has a tip we don't know about.
-                        conflicts.push(tjp);
-                    }
-                }
-            }
-
-            // Lock conflicts
-            for (const tjp of conflicts) {
-                if (logalot) { console.log(`${lc} Conflict detected for TJP ${tjp}. Acquiring lock...`); }
-                // Lock VALIDITY: 60 seconds?
-                await lockSpace({
-                    space: dest,
-                    scope: tjp,
-                    secondsValid: 60,
-                    instanceId: uuid,
-                });
-
-                // todo: Implement Pull & Merge here
-                // 1. Pull delta from Dest (destTip -> ... -> common ancestor)
-                // 2. Merge locally
-                // 3. Update graph/timelinesMap with merged result
-
-                if (logalot) { console.warn(`${lc} Merge not fully implemented yet. Releasing lock.`); }
-
-                await unlockSpace({
-                    space: dest,
-                    scope: tjp,
-                    instanceId: uuid,
-                });
-            }
-
             const initFrame = await this.createSyncFrame({
                 uuid,
                 stage: SyncStage.init,
                 payload: initData,
                 identity
             });
-
-            // Persist Init to Dest (Handshake)
             await putInSpace({ space: dest, ibGib: initFrame });
 
-            // 3. DELTA
-            // const payloadAddrs = [getIbGibAddr({ ibGib: identity })]; // Already computed above
+            // Phase 2: Resolving Conflicts (Pull/Merge)
+            await this.resolveConflicts({
+                source,
+                dest,
+                srcTimelinesMap,
+                srcKnowledgeVector,
+                srcGraph,
+                uuid,
+                conflictStrategy: conflictStrategy || 'abort',
+            });
 
-            const deltaData: SyncDeltaData = {
-                payloadAddrs
-            };
+            // ---------------------------------------------------------
+            // 4. Batch Stream (Delta)
+            // ---------------------------------------------------------
+            const payloadAddrs: string[] = [];
+            payloadAddrs.push(...srcStones.map(x => getIbGibAddr({ ibGib: x })));
+            srcSortedTjps.forEach(tjp => {
+                const timeline = srcTimelinesMap[tjp];
+                payloadAddrs.push(...timeline.map(x => getIbGibAddr({ ibGib: x })));
+            });
+
+            const deltaData: SyncDeltaData = { payloadAddrs };
             const deltaFrame = await this.createSyncFrame({
                 uuid,
                 stage: SyncStage.delta,
@@ -283,32 +222,17 @@ export class SyncSagaCoordinator {
             });
             await putInSpace({ space: dest, ibGib: deltaFrame });
 
-            // 3.1 Stream the actual data (Batch Stream)
-            // We must preserve the order in payloadAddrs to respect dependencies.
-            // We batch them to improve throughput.
-            const BATCH_SIZE = 20;
-            for (let i = 0; i < payloadAddrs.length; i += BATCH_SIZE) {
-                const chunkAddrs = payloadAddrs.slice(i, i + BATCH_SIZE);
-                const chunkIbGibs = chunkAddrs
-                    .map(addr => {
-                        const ibGib = graph[addr];
-                        if (!ibGib) { throw new Error(`(UNEXPECTED) addr not found in graph: ${addr} (E: 8a402324057849318625aa85721665a5)`); }
-                        return ibGib;
-                    })
-                    .filter(ibGib => !isPrimitive({ ibGib }));
-
-                if (chunkIbGibs.length > 0) {
-                    if (logalot) { console.log(`${lc} streaming batch ${Math.ceil(i / BATCH_SIZE) + 1} (${chunkIbGibs.length} ibGibs)...`); }
-                    // We don't set isDna: true here because the batch might contain mixed types.
-                    // The Space implementation should handle routing based on internal metadata if needed.
-                    await putInSpace({ space: dest, ibGibs: chunkIbGibs });
-                }
-            }
+            // Streaming Logic
+            await this.processBatchStream({
+                dest,
+                payloadAddrs,
+                srcGraph
+            });
 
-            // 4. COMMIT
-            const commitData: SyncCommitData = {
-                success: true
-            };
+            // ---------------------------------------------------------
+            // 5. Commit
+            // ---------------------------------------------------------
+            const commitData: SyncCommitData = { success: true };
             const commitFrame = await this.createSyncFrame({
                 uuid,
                 stage: SyncStage.commit,
@@ -325,6 +249,273 @@ export class SyncSagaCoordinator {
         }
     }
 
+    /**
+     * Analyses the timelines in the provided graph, classifying them into stones and living timelines,
+     * and performing topological sort on the timelines.
+     */
+    protected async analyzeTimelines({
+        domainIbGibs,
+        space,
+    }: {
+        domainIbGibs: IbGib_V1[],
+        space: IbGibSpaceAny,
+    }): Promise<{
+        srcStones: IbGib_V1[],
+        srcTimelinesMap: { [tjp: string]: IbGib_V1[] },
+        srcSortedTjps: string[],
+        srcGraph: { [addr: string]: IbGib_V1 },
+    }> {
+        const lc = `${this.lc}[${this.analyzeTimelines.name}]`;
+        const srcGraph = await getDependencyGraph({
+            ibGibs: domainIbGibs,
+            live: true,
+            space,
+        });
+
+        const srcGraphIsValid = srcGraph && Object.keys(srcGraph).length > 0;
+        if (logalot) { console.log(`${lc} graph generated. nodes: ${srcGraphIsValid ? Object.keys(srcGraph).length : 0}`); }
+
+        const srcIbGibs = srcGraphIsValid ? Object.values(srcGraph) : [];
+        const {
+            mapWithTjp_YesDna: srcMapWithTjp_YesDna,
+            mapWithTjp_NoDna: srcMapWithTjp_NoDna,
+            mapWithoutTjps: src_MapWithoutTjps
+        } = splitPerTjpAndOrDna({ ibGibs: srcIbGibs });
+
+        const srcStones = Object.values(src_MapWithoutTjps);
+        const srcLiving = [...Object.values(srcMapWithTjp_YesDna), ...Object.values(srcMapWithTjp_NoDna)];
+
+        if (logalot) {
+            console.log(`${lc} classification results (count):`);
+            console.log(`srcStones.length: ${srcStones.length}`);
+            console.log(`srcLiving.length: ${srcLiving.length}`);
+        }
+
+        const srcTimelinesMap = getTimelinesGroupedByTjp({ ibGibs: srcLiving });
+        const srcSortedTjps = this.sortTimelinesTopologically(srcTimelinesMap);
+
+        return { srcStones, srcTimelinesMap, srcSortedTjps, srcGraph };
+    }
+
+    protected async resolveConflicts({
+        source,
+        dest,
+        srcTimelinesMap,
+        srcKnowledgeVector,
+        srcGraph,
+        uuid,
+        conflictStrategy,
+    }: {
+        source: IbGibSpaceAny,
+        dest: IbGibSpaceAny,
+        srcTimelinesMap: { [tjp: string]: IbGib_V1[] },
+        srcKnowledgeVector: { [tjp: string]: string },
+        srcGraph: { [addr: string]: IbGib_V1 },
+        uuid: string,
+        conflictStrategy: SyncConflictStrategy,
+    }): Promise<void> {
+        const lc = `${this.lc}[${this.resolveConflicts.name}]`;
+
+        const srcTjps = Object.keys(srcTimelinesMap);
+        if (logalot) { console.log(`${lc} getting latest addrs from space as destKnowledge. srcTjps: ${srcTjps} (I: a954369f2b58843a6773b00dd18eb325)`); }
+
+        // Get Dest Knowledge
+        const destKnowledge = await this.getLatestAddrsFromSpace({ space: dest, tjpAddrs: srcTjps });
+        if (logalot) { console.log(`${lc} destKnowledge:\n${pretty(destKnowledge)} (I: f76108b5f228f4e2e1e79ad387deb325)`); }
+
+        const conflicts: string[] = [];
+        for (const tjp of srcTjps) {
+            const srcTimeline = srcTimelinesMap[tjp];
+            const srcTip = srcTimeline[srcTimeline.length - 1];
+            const srcTipAddr = getIbGibAddr({ ibGib: srcTip });
+            const destTipAddr = destKnowledge[tjp];
+
+            if (logalot) {
+                console.log(`${lc} Checking TJP: ${tjp}`);
+                console.log(`${lc}   Source Tip: ${srcTipAddr}`);
+                console.log(`${lc}   Dest Tip:   ${destTipAddr}`);
+            }
+
+            if (destTipAddr && destTipAddr !== srcTipAddr) {
+                if (logalot) { console.log(`${lc} Divergence found. Check if Source knows Dest's tip. (I: d084d8abb6a84cc4a8301b51dec98825)`); }
+                if (srcGraph[destTipAddr]) {
+                    // Fast-Forward: Dest tip IS in our graph, so we are ahead.
+                    // No action needed, proceed to push.
+                    if (logalot) { console.log(`${lc}   Fast-Forward (Source is ahead).`); }
+                } else {
+                    // Conflict: Dest has a tip we don't know about.
+                    conflicts.push(tjp);
+                    if (logalot) { console.log(`${lc}   CONFLICT detected (Desc is ahead/divergent).`); }
+                }
+            } else {
+                if (logalot) { console.log(`${lc}   No divergence detected (Tips match or Dest unknown).`); }
+            }
+        }
+
+        // Lock conflicts
+        for (const tjp of conflicts) {
+            if (logalot) { console.log(`${lc} Conflict detected for TJP ${tjp}. Acquiring lock...`); }
+            // Lock VALIDITY: 60 seconds?
+            await lockSpace({
+                space: dest,
+                scope: tjp,
+                secondsValid: 60,
+                instanceId: uuid,
+            });
+
+            // Pull & Merge Logic
+            try {
+                const destTipAddr = destKnowledge[tjp];
+                if (!destTipAddr) {
+                    console.warn(`${lc} destTipAddr falsy in conflict loop? skipping. (W: 1a2b3c)`);
+                    continue;
+                }
+                const srcTipAddr = srcKnowledgeVector[tjp];
+
+                if (logalot) { console.log(`${lc} Pulling TJP ${tjp} from Dest...`); }
+
+                // 1. Get Delta from Dest
+                // We want everything from Dest's tip back to what Source has.
+                // We can use getDependencyGraph with 'skipAddrs' if we know what to skip.
+                // Or just get the graph for the tip and filter?
+                // Graph helper is robust. Let's try to get the graph stopping at Source's tip.
+
+                // Optimization: We can't easily pass "stop at" to getDependencyGraph directly like "stopAt: [srcTipAddr]",
+                // but we can pass `gotten` or `skipAddrs`.
+                // If we pass `skipAddrs: [srcTipAddr]`, it should prune the graph traversal beyond that point?
+                // Actually `skipAddrs` prevents retrieving that node AND its past. So yes!
+
+                const skipAddrs: string[] = [];
+                if (srcTipAddr) { skipAddrs.push(srcTipAddr); }
+
+                const deltaGraph = await getDependencyGraph({
+                    space: dest,
+                    ibGibs: [],
+                    ibGibAddrs: [destTipAddr],
+                    live: false, // We usually just want the static graph back to the divergence point for now? Or live? Live is safer but slower. 
+                    // If Dest is ahead, its tip IS the latest.
+                    skipAddrs,
+                });
+
+                if (logalot) { console.log(`${lc} Delta graph size: ${Object.keys(deltaGraph).length}`); }
+
+                // 2. Put Delta into Source
+                const deltaIbGibs = Object.values(deltaGraph);
+                if (deltaIbGibs.length > 0) {
+                    if (logalot) {
+                        console.log(`${lc} Putting ${deltaIbGibs.length} ibGibs into Source (UUID: ${(source as any).data?.uuid})...`);
+                        console.log(`${lc} Delta addrs: ${deltaIbGibs.map(x => getIbGibAddr({ ibGib: x })).join(', ')}`);
+                    }
+                    await putInSpace({ space: source, ibGibs: deltaIbGibs });
+                    if (logalot) { console.log(`${lc} Put complete.`); }
+                }
+
+                // 3. Re-evaluate / Merge
+                // Now Source has destTipAddr.
+                // If Source was strictly behind, srcTipAddr was an ancestor of destTipAddr.
+                // Source is now effectively fast-forwarded to destTipAddr.
+
+                // We need to check if we need to do a "Merge" (i.e. if Source HAD changes that are not in Dest).
+                // If srcTipAddr was in deltaGraph (Wait, we skipped it), or rather if srcTipAddr is an ancestor of destTip.
+                // If `skipAddrs` worked, we stopped AT srcTipAddr.
+
+                // Ideally check if `destTipAddr` reaches `srcTipAddr`.
+                // For now, in "Dest Ahead" scenario, we just assume we updated Source.
+                // We update our local tracking to proceed with potential Pushing back (if we were merging).
+
+                // If we simply pulled, do we need to push back?
+                // If Dest was strictly ahead, Source catch up. Source == Dest. No Push needed.
+                // Logic:
+                // If Source now has destTipAddr as Latest, we are good.
+
+                // TODO: Handle actual DIVERGENCE (Merge). 
+                // This implementation covers "Dest Ahead" (Fast-Backward).
+                // But if we truly diverged (Source has changes not in Dest, and Dest has changes not in Source),
+                // checks are needed.
+
+                // If conflictStrategy is abort, we should probably check if `srcTipAddr` is an ancestor of `destTipAddr`.
+                // If `srcTipAddr` is NOT an ancestor, then we have a divergence. 
+                // Getting ancestry is expensive without graph traversal.
+                // But we just pulled `deltaGraph`. If `srcTipAddr` was `skipped` during traversal,
+                // it implies it WAS reachable from `destTipAddr`.
+                // Wait, `skipAddrs` just stops traversal. It doesn't confirm reachability if we assume it stops *at* the addr.
+                // Actually `getDependencyGraph` with `skipAddrs` stops descending if it hits a skipped addr.
+                // If it hits it, it means `srcTipAddr` IS an ancestor.
+                // If it never hits it, `srcTipAddr` might NOT be an ancestor (divergence).
+                // Or `srcTipAddr` is just disjoint?
+
+                // Let's rely on the fact that if we simply "Pull", we are essentially overwriting Source's "Latest" pointer 
+                // if we don't do anything else.
+                // If Source had 'A', and Dest had 'B', and we pull 'B'. Source now has 'A' and 'B'.
+                // If we don't merge, Source is now just "containing" B.
+
+                if (conflictStrategy === 'abort') {
+                    // Verify if it's a true divergence or just a Fast-Forward we haven't tracked yet.
+                    // If srcTipAddr is an ancestor of destTipAddr, it is a valid FF.
+                    if (srcTipAddr) {
+                        const isFF = await this.isAncestor({
+                            ancestorAddr: srcTipAddr,
+                            descendantAddr: destTipAddr,
+                            space: source
+                        });
+                        if (isFF) {
+                            if (logalot) { console.log(`${lc} Verified Fast-Forward/Pull (srcTip is ancestor). No abort.`); }
+                        } else {
+                            throw new Error(`Sync Aborted: Divergence detected on TJP ${tjp}. Source Tip: ${srcTipAddr}, Dest Tip: ${destTipAddr}. Strategy is 'abort'.`);
+                        }
+                    } else {
+                        // source has no tip (new timeline for source), so it's a valid pull.
+                    }
+                } else if (conflictStrategy === 'optimistic') {
+                    console.warn(`${lc} Optimistic merge not yet fully implemented. Proceeding with Pulled data but Source Tip is still the effective 'latest' for this session unless merged. (W: todo_merge)`);
+                }
+
+            } catch (err) {
+                console.error(`${lc} Error dealing with conflict/pull for TJP ${tjp}: ${extractErrorMsg(err)}`);
+                if (conflictStrategy === 'abort') throw err;
+            }
+
+            await unlockSpace({
+                space: dest,
+                scope: tjp,
+                instanceId: uuid,
+            });
+        }
+    }
+
+    protected async processBatchStream({
+        dest,
+        payloadAddrs,
+        srcGraph
+    }: {
+        dest: IbGibSpaceAny,
+        payloadAddrs: string[],
+        srcGraph: { [addr: string]: IbGib_V1 }
+    }): Promise<void> {
+        const lc = `${this.lc}[${this.processBatchStream.name}]`;
+        // 3.1 Stream the actual data (Batch Stream)
+        // We must preserve the order in payloadAddrs to respect dependencies.
+        // We batch them to improve throughput.
+        const BATCH_SIZE = 20;
+        for (let i = 0; i < payloadAddrs.length; i += BATCH_SIZE) {
+            const chunkAddrs = payloadAddrs.slice(i, i + BATCH_SIZE);
+            const chunkIbGibs = chunkAddrs
+                .map(addr => {
+                    const ibGib = srcGraph[addr];
+                    if (!ibGib) { throw new Error(`(UNEXPECTED) addr not found in graph: ${addr} (E: 8a402324057849318625aa85721665a5)`); }
+                    return ibGib;
+                })
+                .filter(ibGib => !isPrimitive({ ibGib }));
+
+            if (chunkIbGibs.length > 0) {
+                if (logalot) { console.log(`${lc} streaming batch ${Math.ceil(i / BATCH_SIZE) + 1} (${chunkIbGibs.length} ibGibs)...`); }
+                // We don't set isDna: true here because the batch might contain mixed types.
+                // The Space implementation should handle routing based on internal metadata if needed.
+                await putInSpace({ space: dest, ibGibs: chunkIbGibs });
+            }
+        }
+    }
+
     protected async createSyncFrame({
         uuid,
         stage,
@@ -377,34 +568,49 @@ export class SyncSagaCoordinator {
     }: {
         space: IbGibSpaceAny,
         tjpAddrs: string[],
-    }): Promise<{ [tjpAddr: string]: string }> {
+    }): Promise<{ [tjpAddr: string]: string | null }> {
         const lc = `${this.lc}[${this.getLatestAddrsFromSpace.name}]`;
         try {
-            if (tjpAddrs.length === 0) { return {}; }
+            if (tjpAddrs.length === 0) {
+                console.warn(`${lc} getting latest addrs for empty tjpAddrs? this may be reasonable but sounds odd. (W: 2f57c6d7c195034e982dfd38201db825)`);
+                return {};
+            }
 
-            // Using the space's witness/argy pattern to invoke 'get' with 'latest' modifier
-            const arg = await space.argy({
-                ibMetadata: getSpaceArgMetadata({ space }),
-                argData: {
-                    cmd: 'get',
-                    cmdModifiers: ['latest', 'addrs'],
-                    ibGibAddrs: tjpAddrs,
-                }
+            let map: { [tjp: string]: string | null } = {};
+            const resLatest = await getLatestAddrs({
+                tjpAddrs,
+                space,
             });
-            const result = await space.witness(arg);
-
-            const map: { [tjp: string]: string } = {};
-            if (result?.data?.success && result.data.addrs) {
-                // assume 1-to-1 mapping order as per convention if successful
-                // verification is hard without specific return map
-                if (result.data.addrs.length === tjpAddrs.length) {
-                    for (let i = 0; i < tjpAddrs.length; i++) {
-                        map[tjpAddrs[i]] = result.data.addrs[i];
-                    }
-                } else {
-                    console.warn(`${lc} result addrs length mismatch. requested: ${tjpAddrs.length}, got: ${result.data.addrs.length}. Mapping might be unsafe.`);
-                }
+            if (!resLatest.data) { throw new Error(`(UNEXPECTED) resLatest.data falsy? (E: 289dd61a79fa33a4f87baaa83e3c0825)`); }
+            if (resLatest.data.success) {
+                map = clone(resLatest.data.latestAddrsMap) as { [key: string]: string | null };
+            } else {
+                tjpAddrs.forEach(x => { map[x] = null; });
             }
+
+            // Using the space's witness/argy pattern to invoke 'get' with 'latest' modifier
+            // const arg = await space.argy({
+            //     ibMetadata: getSpaceArgMetadata({ space }),
+            //     argData: {
+            //         cmd: 'get',
+            //         cmdModifiers: ['latest', 'addrs'],
+            //         ibGibAddrs: tjpAddrs,
+            //     }
+            // });
+            // const result = await space.witness(arg);
+
+            // const map: { [tjp: string]: string } = {};
+            // if (result?.data?.success && result.data.addrs) {
+            //     // assume 1-to-1 mapping order as per convention if successful
+            //     // verification is hard without specific return map
+            //     if (result.data.addrs.length === tjpAddrs.length) {
+            //         for (let i = 0; i < tjpAddrs.length; i++) {
+            //             map[tjpAddrs[i]] = result.data.addrs[i];
+            //         }
+            //     } else {
+            //         console.warn(`${lc} result addrs length mismatch. requested: ${tjpAddrs.length}, got: ${result.data.addrs.length}. Mapping might be unsafe.`);
+            //     }
+            // }
             return map;
         } catch (error) {
             console.error(`${lc} ${extractErrorMsg(error)}`);
@@ -474,4 +680,48 @@ export class SyncSagaCoordinator {
 
         return sorted;
     }
+
+    /**
+     * Checks if an address is an ancestor of another by traversing `past` relations.
+     * Uses BFS. Returns true if `ancestorAddr` is found in the history of `descendantAddr`.
+     */
+    protected async isAncestor({
+        ancestorAddr,
+        descendantAddr,
+        space,
+    }: {
+        ancestorAddr: string,
+        descendantAddr: string,
+        space: IbGibSpaceAny,
+    }): Promise<boolean> {
+        if (ancestorAddr === descendantAddr) return true;
+
+        const queue = [descendantAddr];
+        const visited = new Set<string>();
+
+        while (queue.length > 0) {
+            const currentAddr = queue.shift()!;
+            if (visited.has(currentAddr)) continue;
+            visited.add(currentAddr);
+
+            if (currentAddr === ancestorAddr) return true;
+
+            // Get node to find past
+            const res = await getFromSpace({ space, addr: currentAddr });
+            if (!res.success || !res.ibGibs || res.ibGibs.length === 0) {
+                continue;
+            }
+            const node = res.ibGibs[0];
+            if (node.rel8ns && node.rel8ns.past) {
+                // Check pasts
+                for (const pastAddr of node.rel8ns.past) {
+                    if (!visited.has(pastAddr)) {
+                        queue.push(pastAddr);
+                    }
+                }
+            }
+        }
+
+        return false;
+    }
 }