@ibgib/core-gib 0.1.23 → 0.1.26

package/dist/sync/sync-saga-coordinator.mjs

@@ -5,13 +5,13 @@ import { Factory_V1 } from "@ibgib/ts-gib/dist/V1/factory.mjs";
 import { putInSpace, getLatestAddrs, getFromSpace } from "../witness/space/space-helper.mjs";
 import { SyncStage, SYNC_ATOM, SYNC_MSG_REL8N_NAME, SYNC_SAGA_PAYLOAD_ADDRS_DOMAIN } from "./sync-constants.mjs";
 import { appendToTimeline, createTimeline } from "../timeline/timeline-api.mjs";
-import { SyncConflictStrategy, SyncMode, } from "./sync-types.mjs";
+import { SyncConflictStrategy, SyncMode, SYNC_CONFLICT_STRATEGY_VALID_VALUES, } from "./sync-types.mjs";
 import { getSyncIb, getTempSpaceName, isPastFrame } from "./sync-helpers.mjs";
-import { getDependencyGraph, toFlatGraph } from "../common/other/graph-helper.mjs";
+import { getDeltaDependencyGraph, getDependencyGraph, toFlatGraph } from "../common/other/graph-helper.mjs";
 import { getSyncSagaMessageIb } from "./sync-saga-message/sync-saga-message-helpers.mjs";
 import { SYNC_SAGA_MSG_ATOM } from "./sync-saga-message/sync-saga-message-constants.mjs";
 import { splitPerTjpAndOrDna, getTimelinesGroupedByTjp, isIbGib } from "../common/other/ibgib-helper.mjs";
-import { createSyncSagaContext } from "./sync-saga-context/sync-saga-context-helpers.mjs";
+import { createSyncSagaContext, validateContextAndSagaFrame } from "./sync-saga-context/sync-saga-context-helpers.mjs";
 import { newupSubject, } from "../common/pubsub/subject/subject-helper.mjs";
 import { mergeDivergentTimelines } from "./strategies/conflict-optimistic.mjs";
 import { getSyncSagaMessageFromFrame } from "./sync-saga-message/sync-saga-message-helpers.mjs";
@@ -95,30 +95,29 @@ export class SyncSagaCoordinator {
         // Async execution wrapper
         (async () => {
             try {
-                // 2. BOOTSTRAP IDENTITY (Session Keystone)
+                // BOOTSTRAP IDENTITY (Session Keystone)
                 const sessionIdentity = useSessionIdentity
                     ? await this.getSessionIdentity({ sagaId, metaspace, tempSpace })
                     : undefined;
                 // if (logalot) { console.log(`${lc} sessionIdentity: ${sessionIdentity ? pretty(sessionIdentity) : 'undefined'} (I: abc01872800b3a66b819a05898bba826)`); }
-                // 3. CREATE INITIAL FRAME (Stage.init)
-                const { sagaFrame: initFrame, initialDomainGraph } = await this.createInitFrame({
+                // CREATE INITIAL FRAME (Stage.init)
+                const { initFrame, initDomainGraph } = await this.createInitFrame({
                     sagaId,
                     sessionIdentity,
                     domainIbGibs,
                     conflictStrategy,
                     metaspace, localSpace, tempSpace,
                 });
-                // 4. KICK OFF THE PING-PONG SAGA LOOP (FSM)
-                // commented to compile
-                // await this.executeSagaLoop({
-                //     initialFrame: initFrame,
-                //     peer,
-                //     sessionIdentity,
-                //     updates$,
-                //     localSpace,
-                //     tempSpace,
-                //     metaspace
-                // });
+                // KICK OFF THE PING-PONG SAGA LOOP (FSM)
+                await this.executeSagaLoop({
+                    initFrame, initDomainGraph,
+                    peer,
+                    sessionIdentity,
+                    updates$,
+                    localSpace,
+                    tempSpace,
+                    metaspace
+                });
                 resolveDone();
                 if (!updates$.complete) {
                     throw new Error(`(UNEXPECTED) updates$.complete falsy? (E: d24cd82184aec130c89a320819b39126)`);
@@ -143,6 +142,75 @@ export class SyncSagaCoordinator {
             done
         };
     }
+    /**
+     * This is what the receiving side of the sync calls to drive the FSM to the
+     * next stage.
+     *
+     * So whereas the sender executes a saga loop and drives the entire process,
+     * this is a reactive one-off that drives just the single step that the
+     * receiver does in that saga.
+     *
+     * @returns next context result if another round, else if commit returns
+     * null
+     */
+    async receiverContinueSync({ sagaContext, mySpace, myTempSpace, identity, identitySecret, metaspace, }) {
+        const lc = `${this.lc}[${this.receiverContinueSync.name}]`;
+        try {
+            if (logalot) {
+                console.log(`${lc} starting... (I: f64e08bf77d1425378601f380384ec26)`);
+            }
+            const contextResult = await this.handleResponseSagaContext({
+                sagaContext,
+                mySpace,
+                myTempSpace,
+                identity,
+                identitySecret,
+                metaspace,
+            });
+            if (!contextResult) {
+                if (logalot) {
+                    console.log(`${lc} Handler returned null (Saga End). (I: 43da8bb6c846b1fe7766332643be0e26)`);
+                }
+                return null;
+            }
+            // #region error conditions throw
+            if (contextResult.errorMsg) {
+                throw new Error(`Couldn't handle response saga context. errorMsg: ${contextResult.errorMsg} (E: 7b41a183cf3cb58a5859c803800cf826)`);
+            }
+            else if (!contextResult.nextFrameInfo) {
+                throw new Error(`(UNEXPECTED) contextResult.nextFrameInfo falsy? (E: 5740542f5eb8ccb41dfec188d87c1e26)`);
+            }
+            else if (contextResult.nextFrameInfo?.responseWasNull) {
+                throw new Error(`(UNEXPECTED) contextResult.nextFrameInfo.responseWasNull? logic flow should not have gotten here. (E: ae06748d8c0c5e70c92322c8fb0cb426)`);
+            }
+            // #endregion error conditions throw
+            // create the return context
+            const { frame, payloadIbGibsDomain } = contextResult.nextFrameInfo;
+            const responseCtx = await createSyncSagaContext({
+                sagaFrame: frame,
+                localSpace: mySpace,
+                payloadIbGibsDomain,
+                // todo: we need to thoroughly go through the identity per each step after getting basic merging
+                sessionKeystones: identity ? [identity] : undefined, // ??
+            });
+            const immediateValidationErrors = await validateContextAndSagaFrame({
+                context: responseCtx,
+            });
+            if (immediateValidationErrors.length > 0) {
+                throw new Error(`(UNEXPECTED) just created sync saga context () and there were immediateValidationErrors? immediateValidationErrors: ${immediateValidationErrors} (E: c120e8e0aa98673d685267a8a36e5826)`);
+            }
+            return responseCtx;
+        }
+        catch (error) {
+            console.error(`${lc} ${extractErrorMsg(error)}`);
+            throw error;
+        }
+        finally {
+            if (logalot) {
+                console.log(`${lc} complete.`);
+            }
+        }
+    }
     async getSessionIdentity({ sagaId, metaspace, tempSpace, }) {
         const lc = `${this.lc}[${this.getSessionIdentity.name}]`;
         try {
@@ -189,45 +257,23 @@ export class SyncSagaCoordinator {
      * the NEXT request context.
      * When the Peer responds with data (in the response context), it is resolved and put into `tempSpace`.
      */
-    async executeSagaLoop({ initialFrame, initialDomainGraph, peer, sessionIdentity, updates$, localSpace, tempSpace, metaspace }) {
+    async executeSagaLoop({ initFrame, initDomainGraph, peer, sessionIdentity, updates$, localSpace, tempSpace, metaspace }) {
         const lc = `${this.lc}[${this.executeSagaLoop.name}]`;
-        // The current frame we just generated (e.g., Init or Delta Request)
-        let currentFrame = initialFrame;
-        // The payload we need to attach to the message (data we are sending)
+        /** The current frame we just generated (e.g., Init or Delta Request) */
+        let currentFrame = initFrame;
+        /** The **domain** payload we need to transmit (data we are sending) */
         let nextDomainIbGibs = [];
-        // First, inject local/tempSpace into peer so it can pull as
-        // needed...code smell?
-        peer.senderSpace = localSpace;
-        peer.senderTempSpace = tempSpace;
         while (currentFrame) {
-            // A. Create Context (Request)
-            // 1. Calculate Full Dependency Graph (including Ancestors/DNA)
-            // We must do this BEFORE creating the Context so we can list them
-            // all in payloadAddrsDomain and payloadAddrsControl.
-            const nextDomainIbGibsAndDeps = [];
-            // A. Payload (Standard Deep Deps)
-            // TODO: THIS IS EXTREMELY INEFFICIENT. adjust this algorithm to
-            // only do the dependencies that the other end doesn't need (diff
-            // between tip and LCA). This can be done using the information in
-            // the ack's conflicts array.
-            for (const nextDomainIbGib of nextDomainIbGibs) {
-                let nextDomainIbGibGraph = await getDependencyGraph({ ibGib: nextDomainIbGib, space: localSpace });
-                if (!nextDomainIbGibGraph) {
-                    nextDomainIbGibGraph = await getDependencyGraph({ ibGib: nextDomainIbGib, space: tempSpace });
-                }
-                if (nextDomainIbGibGraph) {
-                    nextDomainIbGibsAndDeps.push(...Object.values(nextDomainIbGibGraph));
-                }
-                else {
-                    throw new Error(`(UNEXPECTED) we couldn't get the graph for a known domain ibgib? nextDomainIbGib addr: ${getIbGibAddr({ ibGib: nextDomainIbGib })} (E: 01b3e4db8768b5b77db72e486f4f7826)`);
-                }
-            }
-            if (logalot) {
-                console.log(`${lc} payloadIbGibsDomain count: ${nextDomainIbGibsAndDeps.length} (I: 2beda8ca7dc5ac0f48ed9e25e704b826)`);
-            }
-            // 2. Create Context (Envelope)
-            // set up subscription for response's payload ibgibs (if any)
+            // first, prepare for context transmission...
+            /**
+             * this is used later in pollForDomainPayloads **iif** payloads are
+             * received **in the response**, i.e., on the return trip. So if we
+             * request addrs, the response should have these addrs and their
+             * dependencies. The ibgibs corresponding to these addrs will be
+             * streamed and placed into this map.
+             */
             const domainPayloadsMap = new Map();
+            // #region set up peer observable for any domainPayloadsMap
             const sublc = `${lc}[peer.payloadIbGibsDomainReceived$]`;
             const subscription = await peer.payloadIbGibsDomainReceived$.subscribe(fnObs({
                 next: async (ibgib) => {
@@ -256,38 +302,45 @@ export class SyncSagaCoordinator {
                     await subscription.unsubscribe();
                 },
             }));
-            // Create the Request Context...
+            // #endregion set up peer observable for any domainPayloadsMap
+            // ...create/compose the Request Context itself...
             const requestCtx = await createSyncSagaContext({
                 sagaFrame: currentFrame,
                 sessionKeystones: sessionIdentity ? [sessionIdentity] : undefined,
                 /**
                  * init frame: empty
-                 *
+                 * ack frame: possible push offers
+                 * delta frame: requested ibgibs or commit offer
+                 * commit frame: empty
                  */
-                payloadIbGibsDomain: nextDomainIbGibsAndDeps,
+                payloadIbGibsDomain: nextDomainIbGibs,
                 localSpace,
             });
-            // Log what we're sending
+            // #region Log what we're sending
             if (logalotControlDomain) {
-                const domainAddrs = nextDomainIbGibsAndDeps.map(p => getIbGibAddr({ ibGib: p }));
-                console.log(`${lc}${lcControlDomain} SENDER TRANSMIT -> peer.witness (I: b3c4d5e6f7a8b9c0)`);
+                const domainAddrs = nextDomainIbGibs.map(p => getIbGibAddr({ ibGib: p }));
+                console.log(`${lc}${lcControlDomain} SENDER TRANSMIT -> peer.witness (I: 5b0081803698770f0bf64992220b312)`);
                 console.log(`${lc}${lcControlDomain}   Context: ${getIbGibAddr({ ibGib: requestCtx })}`);
                 console.log(`${lc}${lcControlDomain}   Frame: ${getIbGibAddr({ ibGib: currentFrame })}`);
                 console.log(`${lc}${lcControlDomain}   DOMAIN Payloads (${domainAddrs.length}): ${domainAddrs.join(', ') || '(none)'}`);
             }
+            // #endregion Log what we're sending
             // update our saga listeners...
             // if (logalot) { console.log(`${lc} transmitting... requestCtx: ${pretty(requestCtx)} (I: 8cf20817c66899abdb1e76df50356826)`); }
-            updates$.next(requestCtx); // spins off 
-            // ...And send the context
+            updates$.next(requestCtx); // spins off for saga UI updates
+            // ...And send the context.
+            peer.setOptionalOpts({ senderSpace: localSpace, senderTempSpace: tempSpace, });
             const responseCtx = await peer.witness(requestCtx);
-            // C. Handle Response
+            // the send returned, but a peer can return a falsy responseCtx, if
+            // we just sent a commit to them and they're done. If so, there will
+            // necessarily be no payload to wait to receive
             if (!responseCtx) {
                 if (currentFrame) {
                     // Check for Commit (Peer silence expected)
                     const msg = await getSyncSagaMessageFromFrame({ frameIbGib: currentFrame, space: localSpace });
                     if (msg?.data?.stage === SyncStage.commit) {
                         if (logalot) {
-                            console.log(`${lc} Sender sent Commit. Peer returned no response. Saga Complete.`);
+                            console.log(`${lc} Sender sent Commit. Peer returned no response. Saga Complete. (I: 26f9ee073858ca78b8284753368b5226)`);
                         }
                         currentFrame = null;
                         break;
@@ -300,19 +353,23 @@ export class SyncSagaCoordinator {
                     throw new Error(`(UNEXPECTED) no response and currentFrame falsy? (E: 8d1085ea2f28cfc3f9c922649864a826)`);
                 }
             }
-            // ---------------------------------------------------------------------
-            // 2d. HANDLE RESPONSE
-            // ---------------------------------------------------------------------
-            // at this point, we have received the response context ibgib, but
+            // at this point, we did indeed receive a response to analyze. BUT!
+            // we have only necessarily received the response context ibgib.
             // if there were payloads expected to be transferred, they may not
             // be done yet.
             if (!responseCtx.data) {
                 throw new Error(`(UNEXPECTED) responseCtx.data falsy? (E: a969992bae53ab18a827ec58aec15826)`);
             }
-            updates$.next(responseCtx); // spins off -- don't remove this comment!
+            updates$.next(responseCtx); // spins off for saga UI updating
+            // immediately validate context/saga frame (but not payloads because
+            // we may not have those yet)
+            const contextAndSagaFrameValidationErrors = await validateContextAndSagaFrame({ context: responseCtx });
+            if (contextAndSagaFrameValidationErrors.length > 0) {
+                throw new Error(`contextAndSagaFrameValidationErrors: ${contextAndSagaFrameValidationErrors} (E: 6eebe8e7fa437c00a8cde3ada3c66826)`);
+            }
             // Extract expected domain addresses from response context
             const responsePayloadAddrsDomain = responseCtx.data[SYNC_SAGA_PAYLOAD_ADDRS_DOMAIN] || [];
-            // Poll for them if needed
+            // Poll for them if needed. see above jsdocs for domainPayloadsMap
             if (responsePayloadAddrsDomain.length > 0) {
                 responseCtx.payloadIbGibsDomain = await this.pollForDomainPayloads({
                     expectedAddrs: responsePayloadAddrsDomain,
@@ -321,49 +378,62 @@ export class SyncSagaCoordinator {
                     tempSpace,
                 });
             }
-            // at this point, we have received the context AND **all** of the
-            // domain payloads (if applicable), so we are ready to do the next 
-            // iteration in the saga loop
-            // Log what we received back
+            // #region Log what we received back
             if (!responseCtx.sagaFrame) {
                 throw new Error(`(UNEXPECTED) responseCtx.sagaFrame falsy? the Peer should have set this when it got the response back from the remote. (E: e650adadf9a2063ec6764a1e31d3d826)`);
             }
             if (logalotControlDomain) {
                 const responseControlAddrs = responseCtx.data?.['@payloadAddrsControl'] || [];
-                console.log(`${lc}${lcControlDomain} SENDER RECEIVED <- peer.witness (I: c4d5e6f7a8b9c0d1)`);
+                console.log(`${lc}${lcControlDomain} SENDER RECEIVED <- peer.witness (I: 3dc76a9744d89a4fc3e2f076c2be4826)`);
                 console.log(`${lc}${lcControlDomain}   Response Context: ${getIbGibAddr({ ibGib: responseCtx })}`);
                 console.log(`${lc}${lcControlDomain}   Response Saga Frame: ${getIbGibAddr({ ibGib: responseCtx.sagaFrame })}`);
                 console.log(`${lc}${lcControlDomain}   CONTROL Payloads (${responseControlAddrs.length}): ${responseControlAddrs.join(', ') || '(none)'}`);
                 console.log(`${lc}${lcControlDomain}   DOMAIN Payloads (${responsePayloadAddrsDomain.length}): ${responsePayloadAddrsDomain.join(', ') || '(none)'}`);
             }
-            // Handle Response Frame
-            // interface HandleSagaFrameResult {
-            //     frame: SyncIbGib_V1;
-            //     payloadIbGibsDomain?: IbGib_V1[];
-            //     conflictInfos?: SyncSagaConflictInfo;
-            // }
-            const handleResult = await this.handleSagaContext({
+            // #endregion Log what we received back
+            // at this point, we have received the context AND **all** of the
+            // domain payloads (if applicable), so we are ready to do the next
+            // iteration in the saga loop
+            // this is the part that drives the FSM forward, i.e., when we
+            // evolve the sync saga ibgib itself to the next frame if we aren't
+            // finished/errored out.
+            const contextResult = await this.handleResponseSagaContext({
                 sagaContext: responseCtx,
+                initDomainGraph,
                 mySpace: localSpace,
                 myTempSpace: tempSpace,
                 metaspace,
             });
-            if (!handleResult) {
+            if (!contextResult) {
                 if (logalot) {
-                    console.log(`${lc} Handler returned null (Saga End).`);
+                    console.log(`${lc} Handler returned null (Saga End). (I: faae22abc818ba9b28ac6d2881cd7826)`);
                 }
                 break;
             }
-            currentFrame = handleResult.frame;
-            // Collect next DOMAIN payloads for the NEXT request
-            nextDomainIbGibs = [...(handleResult.payloadIbGibsDomain || [])];
-            // Log handler output for next iteration
+            // #region error conditions throw
+            if (contextResult.errorMsg) {
+                throw new Error(`Couldn't handle response saga context. errorMsg: ${contextResult.errorMsg} (E: c948e81d513b2a0eb8b8afa878edc626)`);
+            }
+            else if (!contextResult.nextFrameInfo) {
+                throw new Error(`(UNEXPECTED) contextResult.nextFrameInfo falsy? (E: c287a82e823e662a77923278e2418826)`);
+            }
+            else if (contextResult.nextFrameInfo?.responseWasNull) {
+                throw new Error(`(UNEXPECTED) contextResult.nextFrameInfo.responseWasNull? logic flow should not have gotten here. (E: 104a32381db816b7183435e805b3d626)`);
+            }
+            // #endregion error conditions throw
+            // we have another frame to process and send out, with possibly
+            // payload domain ibgibs as well
+            const { frame, payloadIbGibsDomain, } = contextResult.nextFrameInfo;
+            currentFrame = frame;
+            nextDomainIbGibs = [...(payloadIbGibsDomain || [])];
+            // #region Log handler output for next iteration
             if (logalotControlDomain) {
                 const handlerDomainAddrs = nextDomainIbGibs.map(p => getIbGibAddr({ ibGib: p }));
-                console.log(`${lc}${lcControlDomain} HANDLER RESULT -> next iteration (I: d5e6f7a8b9c0d1e2)`);
+                console.log(`${lc}${lcControlDomain} HANDLER RESULT -> next iteration (I: 6b0d88c4c28857ccd812381515bd7826)`);
                 console.log(`${lc}${lcControlDomain}   Next Frame: ${getIbGibAddr({ ibGib: currentFrame })}`);
                 console.log(`${lc}${lcControlDomain}   DOMAIN for next (${handlerDomainAddrs.length}): ${handlerDomainAddrs.join(', ') || '(none)'}`);
             }
+            // #endregion Log handler output for next iteration
         }
     }
     /**
@@ -423,7 +493,7 @@ export class SyncSagaCoordinator {
             }
             const res = await getLatestAddrs({ space, tjpAddrs: tjps });
             if (!res.data || !res.data.latestAddrsMap) {
-                throw new Error(`${lc} Failed to get latest addrs. (E: 7a8b9c0d)`);
+                throw new Error(`${lc} Failed to get latest addrs. (E: 7d395940c0e1419165c5196c39c6c826)`);
             }
             // if (false) { console.log(`${lc}[TEST DEBUG] res.data.latestAddrsMap: ${JSON.stringify(res.data.latestAddrsMap)} (I: a8e128bdf80898ac2e6d8021a5bff726)`); }
             return res.data.latestAddrsMap;
@@ -477,7 +547,7 @@ export class SyncSagaCoordinator {
             }
             // Analyze Timelines & Stones
             const analysis = await this.analyzeDomainIbGibs({ domainIbGibs, space: localSpace });
-            // if (logalot) { console.log(`${lc} analysis: ${pretty(analysis)}(I: cd00e2be5eccc8976879c888ff2dfb26)`); } 
+            // if (logalot) { console.log(`${lc} analysis: ${pretty(analysis)}(I: cd00e2be5eccc8976879c888ff2dfb26)`); }
             const { timelinesMap: srcTimelinesMap, fullGraph, stones: srcStones, } = analysis;
             // we need to store the fullGraph in our tempSpace for later...
             await putInSpace({ ibGibs: Object.values(fullGraph), space: tempSpace });
@@ -516,7 +586,7 @@ export class SyncSagaCoordinator {
                 localSpace,
             });
             // if (logalot) { console.log(`${lc} sagaFrame (init): ${pretty(sagaFrame)} (I: b3d6a8be69248f18713cc3073cb08626)`); }
-            return { sagaFrame, initialDomainGraph: fullGraph };
+            return { initFrame: sagaFrame, initDomainGraph: fullGraph };
         }
         catch (error) {
             console.error(`${lc} ${extractErrorMsg(error)}`);
@@ -588,6 +658,7 @@ export class SyncSagaCoordinator {
     }
     /**
      * This is the heart of the "ping pong" transaction, where we send a context
+     *
      * and receive a context. IOW, this drives the FSM of the sync saga ibgib as
      * a whole.
      *
@@ -606,8 +677,8 @@ export class SyncSagaCoordinator {
      *
      * This is a one-off on the receiver.
      */
-    async handleSagaContext({ sagaContext, mySpace, myTempSpace, identity, identitySecret, metaspace, }) {
-        const lc = `${this.lc}[${this.handleSagaContext.name}]`;
+    async handleResponseSagaContext({ sagaContext, initDomainGraph, mySpace, myTempSpace, identity, identitySecret, metaspace, }) {
+        const lc = `${this.lc}[${this.handleResponseSagaContext.name}]`;
         try {
             if (logalot) {
                 console.log(`${lc} starting... (I: 5deec8a1f7a6d263c88cd458ad990826)`);
@@ -628,9 +699,10 @@ export class SyncSagaCoordinator {
              * don't like this name, need to refactor
              */
             const srcGraph = toFlatGraph({ ibGibs: sagaContext.payloadIbGibsDomain }) ?? {};
+            let nextFrameInfo;
             switch (stage) {
                 case SyncStage.init:
-                    return await this.handleInitFrame({
+                    nextFrameInfo = await this.handleInitFrame({
                         sagaIbGib,
                         messageData: messageData,
                         metaspace,
@@ -639,19 +711,36 @@ export class SyncSagaCoordinator {
                         identity,
                         identitySecret
                     });
+                    break;
                 case SyncStage.ack:
-                    return await this.handleAckFrame({ sagaIbGib, srcGraph, metaspace, destSpace: mySpace, tempSpace: myTempSpace, identity });
+                    if (!initDomainGraph) {
+                        throw new Error(`(UNEXPECTED) initDomainGraph falsy on the sender? (E: a3d758ad954829aba88663188eafc826)`);
+                    }
+                    nextFrameInfo = await this.handleAckFrame({
+                        sagaIbGib,
+                        srcGraph,
+                        initDomainGraph,
+                        metaspace,
+                        destSpace: mySpace,
+                        tempSpace: myTempSpace,
+                        identity,
+                    });
+                    break;
                 case SyncStage.delta:
-                    return await this.handleDeltaFrame({ sagaIbGib, srcGraph, metaspace, destSpace: mySpace, tempSpace: myTempSpace, identity, });
+                    nextFrameInfo = await this.handleDeltaFrame({ sagaIbGib, srcGraph, metaspace, destSpace: mySpace, tempSpace: myTempSpace, identity, });
+                    break;
                 case SyncStage.commit:
-                    return await this.handleCommitFrame({ sagaIbGib, metaspace, destSpace: mySpace, tempSpace: myTempSpace, identity, });
+                    nextFrameInfo = await this.handleCommitFrame({ sagaIbGib, metaspace, destSpace: mySpace, tempSpace: myTempSpace, identity, });
+                    break;
                 default:
                     throw new Error(`${lc} (UNEXPECTED) Unknown sync stage: ${stage} (E: 9c2b4c8a6d34469f8263544710183355)`);
             }
+            return { errorMsg: undefined, nextFrameInfo, };
         }
         catch (error) {
-            console.error(`${lc} ${extractErrorMsg(error)}`);
-            throw error;
+            const errorMsg = `${lc} ${extractErrorMsg(error)}`;
+            console.error(errorMsg);
+            return { errorMsg };
         }
         finally {
             if (logalot) {
@@ -680,14 +769,11 @@ export class SyncSagaCoordinator {
             if (logalot) {
                 console.log(`${lc} starting... (I: 9d88dcad0408c029e898a4bcf3b08426)`);
             }
-            console.log(`${lc} [TEST DEBUG] Received destSpace: ${mySpace.data?.name || mySpace.ib} (uuid: ${mySpace.data?.uuid || '[no uuid]'})`);
-            if (logalot) {
-                console.log(`${lc} starting...`);
-            }
+            console.log(`${lc} [TEST DEBUG] Receiver mySpace: ${mySpace.ib}`);
             // Extract Init Data
             const initData = messageData; // Using renamed variable for clarity
             if (initData.stage !== SyncStage.init) {
-                throw new Error(`${lc} Invalid init frame: initData.stage !== SyncStage.init (E: 8a2b3c4d5e6f7g8h)`);
+                throw new Error(`${lc} Invalid init frame: initData.stage !== SyncStage.init (E: c91be82970e4decc58f56bf8fc1ffc26)`);
             }
             // if (logalot) { console.log(`${lc} initData: ${pretty(initData)} (I: 46b0f8441b96ad7a388f1ce3239dd826)`); }
             if (!initData || !initData.knowledgeVector) {
@@ -697,8 +783,8 @@ export class SyncSagaCoordinator {
             const conflictStrategy = sagaIbGib.data.conflictStrategy || SyncConflictStrategy.abort;
             // 2. Gap Analysis
             const conflicts = [];
-            const deltaReqAddrs = [];
-            const pushOfferAddrs = [];
+            const deltaRequestAddrInfos = [];
+            const pushOfferInfos = [];
             // First do the consant stones (Non-TJPs)
             const stones = initData.stones || [];
             if (stones.length > 0) {
@@ -717,14 +803,14 @@ export class SyncSagaCoordinator {
                         console.log(`${lc} stones missing (requesting): ${addrsNotFound.length}`);
                     }
                     addrsNotFound.forEach(addr => {
-                        if (!deltaReqAddrs.includes(addr)) {
-                            deltaReqAddrs.push(addr);
+                        if (!deltaRequestAddrInfos.some(x => x.addr === addr)) {
+                            deltaRequestAddrInfos.push({ addr }); // no tjpAddr
                         }
                     });
                 }
             }
             /**
-             * "remote" local to receiver's context is the sender
+             * "remote" is sender in this case
              */
             const remoteKV = initData.knowledgeVector;
             if (logalot) {
@@ -736,7 +822,7 @@ export class SyncSagaCoordinator {
                 console.log(`${lc} remoteTjps: ${pretty(remoteTjps)} (I: 86ea4c53db0dc184c8b253386c402126)`);
             }
             // 1. Get Local Latest Addrs for all TJPs
-            let localKV = {};
+            let localLatestAddrsMap = {};
             if (remoteTjps.length > 0) {
                 // Batch get latest addrs for the TJPs
                 const resGetLatestAddrs = await getLatestAddrs({
@@ -749,52 +835,88 @@ export class SyncSagaCoordinator {
                 if (!resGetLatestAddrs.data.latestAddrsMap) {
                     throw new Error(`(UNEXPECTED) resGetLatestAddrs.data.latestAddrsMap falsy? (E: 16bc386dd51d0ff53a49620b1e641826)`);
                 }
-                localKV = resGetLatestAddrs.data.latestAddrsMap;
-                console.log(`${lc} [TEST DEBUG] localKV: ${JSON.stringify(localKV)}`);
+                localLatestAddrsMap = resGetLatestAddrs.data.latestAddrsMap;
+                console.log(`${lc} [TEST DEBUG] localKV: ${JSON.stringify(localLatestAddrsMap)}`);
                 if (logalot) {
-                    console.log(`${lc} localKV: ${pretty(localKV)} (I: 980975642cbccd8018cf0cd808d30826)`);
+                    console.log(`${lc} localKV: ${pretty(localLatestAddrsMap)} (I: 980975642cbccd8018cf0cd808d30826)`);
                 }
             }
             // 2. Gap Analysis
             for (const tjp of remoteTjps) {
                 const remoteAddr = remoteKV[tjp];
-                const localAddr = localKV[tjp];
+                const localAddr = localLatestAddrsMap[tjp];
                 if (!localAddr) {
                     // We (Receiver) don't have this timeline at all. Request it.
                     console.log(`${lc} [TEST DEBUG] Missing local timeline for TJP: ${tjp}. Requesting remoteAddr: ${remoteAddr}`);
-                    deltaReqAddrs.push(remoteAddr);
+                    deltaRequestAddrInfos.push({
+                        addr: remoteAddr,
+                        tjpAddr: tjp,
+                        // we don't have this timeline at all
+                        // latestAddrAlreadyHave: undefined
+                    });
                     continue;
                 }
+                // we do have this timeline...
                 if (localAddr === remoteAddr) {
-                    // Synced
+                    // ...already synced
                     console.log(`${lc} [TEST DEBUG] TJP ${tjp}: Synced (localAddr === remoteAddr)`);
                     continue;
                 }
                 console.log(`${lc} [TEST DEBUG] TJP ${tjp}: localAddr=${localAddr}, remoteAddr=${remoteAddr} - checking for divergence...`);
-                // Check if Remote is in Local's PAST (Local is Ahead -> Push Offer)
-                // (Sender has older version, Receiver has newer) -> Receiver Offers Push
-                const isRemoteInPast = await isPastFrame({
+                // we have this timeline but it's not synced...
+                // We're executing on receiver. Check if Remote (Sender) is in
+                // our past, and if so, we are ahead and need to push the delta
+                // to remote
+                const remoteIsInPast = await isPastFrame({
                     olderAddr: remoteAddr,
                     newerAddr: localAddr,
                     space: mySpace,
                 });
-                if (isRemoteInPast) {
-                    console.log(`${lc} [TEST DEBUG] TJP ${tjp}: Remote is in past - offering push`);
-                    pushOfferAddrs.push(localAddr);
+                if (remoteIsInPast) {
+                    // we're ahead, so push the delta of what the sender doesn't
+                    // have (we have full knowledge)
+                    console.log(`${lc} [TEST DEBUG] TJP ${tjp}: Remote (sender) is in past - offering push`);
+                    const deltaGraph = await getDeltaDependencyGraph({
+                        ibGibAddr: localAddr,
+                        live: false, // always live: false right?
+                        latestCommonFrameAddr: remoteAddr,
+                        space: mySpace,
+                    });
+                    pushOfferInfos.push({ tjpAddr: tjp, addrs: Object.keys(deltaGraph), });
                 }
                 else {
-                    // Remote is not in our past. 
-                    // Either Remote is ahead (Fast-Backward) OR Diverged.
+                    // Remote tip is not in our past.  So, either Remote is
+                    // ahead (we're in THEIR past, i.e., Fast-Backward) OR
+                    // Diverged/conflict (we've both made edits).
                     // Check if Local is in Remote's PAST (Remote is Ahead -> Delta Request)
-                    const isLocalInPast = await isPastFrame({
-                        olderAddr: localAddr,
-                        newerAddr: remoteAddr,
-                        space: mySpace,
-                    });
-                    if (isLocalInPast) {
+                    /**
+                     * we could first check for existence of remoteAddr in
+                     * mySpace, but this is quick and easy. If it throws, we
+                     * don't have it so it can't be in the past.
+                     */
+                    let localIsInPast = false;
+                    try {
+                        // we could
+                        localIsInPast = await isPastFrame({
+                            olderAddr: localAddr,
+                            newerAddr: remoteAddr,
+                            space: mySpace,
+                        });
+                    }
+                    catch (error) {
+                        // couldn't get one of them, so localIsInPast remains false.
+                        if (logalot) {
+                            console.log(`${lc} expected error if we don't have remote. verbose logging error though: ${extractErrorMsg(error)} (I: 47ea08d0b418cf4aa8a502a7bcb80826)`);
+                        }
+                    }
+                    if (localIsInPast) {
                         // Fast-Forward: We update to remote's tip.
                         console.log(`${lc} [TEST DEBUG] TJP ${tjp}: Local is in past - requesting delta`);
-                        deltaReqAddrs.push(remoteAddr);
+                        deltaRequestAddrInfos.push({
+                            addr: remoteAddr,
+                            tjpAddr: tjp,
+                            latestAddrAlreadyHave: localAddr,
+                        });
                     }
                     else {
                         // DIVERGENCE: Both have changes the other doesn't know about.
@@ -814,7 +936,7 @@ export class SyncSagaCoordinator {
                             });
                         }
                         else if (conflictStrategy === 'optimistic') {
-                            // Optimistic: We want to resolving this.
+                            // Optimistic: We want resolve this.
                             // We need to send our history to the Sender so they can Merge.
                             // Fetch Full History for Local Timeline
                             // Note: We might optimize this to only send "recent" history if we had a KV?
@@ -825,11 +947,11 @@ export class SyncSagaCoordinator {
                             // We have localAddr.
                             const resLocalTip = await getFromSpace({ space: mySpace, addr: localAddr });
                             if (!resLocalTip.success || resLocalTip.ibGibs?.length !== 1) {
-                                throw new Error(`couldn't get local tip (${localAddr}) from space (${mySpace.ib}) (E: ff06ff849fa8e8dba32ce09807411226)`);
+                                throw new Error(`couldn't get local tip (${localAddr}) from space (${mySpace.ib}) (E: 83cb88a767e22bbda99c6788bec50526)`);
                             }
                             const localTip = resLocalTip.ibGibs[0];
                             if (!localTip) {
-                                throw new Error(`${lc} Failed to load local tip for conflict resolution. (E: 8f9b2c3d4e5f6g7h)`);
+                                throw new Error(`${lc} Failed to load local tip for conflict resolution. (E: c39448ad6b3a72af78339ad877a56826)`);
                             }
                             const timelineAddrs = [...(localTip.rel8ns?.past ?? []), localAddr];
                             conflicts.push({
@@ -842,7 +964,7 @@ export class SyncSagaCoordinator {
                             });
                         }
                         else {
-                            throw new Error(`${lc} Unsupported conflict strategy: ${conflictStrategy} (E: 2a9b3c4d5e6f7g8h9i0j)`);
+                            throw new Error(`${lc} Unsupported conflict strategy: ${conflictStrategy}. Only these currently implemented: ${SYNC_CONFLICT_STRATEGY_VALID_VALUES} (E: 8f12384180f8a718a983a749fe0adf26)`);
                         }
                     }
                 }
@@ -856,51 +978,17 @@ export class SyncSagaCoordinator {
                 }
                 throw new Error(`the saga has terminal conflicts. conflicts: ${JSON.stringify(conflicts)} (E: f2edbe93cc07a63b38bfc013d2213b26)`);
             }
-            // 3. Build Knowledge Vector (Full History for known timelines)
-            // [NEW] Smart Diff
-            // We iterate over all relevant addresses (deltas we are requesting OR push offers we might have newer versions of).
-            // Since we are "reacting" to Init, we primarily want to tell the Sender what we DO have for the things they talked about.
-            /**
-             * we will put this in {@link SyncSagaMessageAckData_V1.knowledgeVector}
-             */
-            const knowledgeVector = {};
-            // [Smart Diff] Populate knowledge from timelines identified by Sender
-            for (const tjp of remoteTjps) {
-                const localAddr = localKV[tjp];
-                if (localAddr) {
-                    const res = await getFromSpace({ addr: localAddr, space: mySpace });
-                    if (res.success && res.ibGibs?.[0]) {
-                        const ibGib = res.ibGibs[0];
-                        const realTjp = ibGib.rel8ns?.tjp?.[0] || getIbGibAddr({ ibGib }); // Should match `tjp` if normalized 
-                        if (!knowledgeVector[realTjp]) {
-                            const past = ibGib.rel8ns?.past || [];
-                            knowledgeVector[realTjp] = [getIbGibAddr({ ibGib }), ...past];
-                        }
-                    }
-                }
-            }
-            // Also populate from `knowledgeVector` in Init if we want bidirectional? 
-            // No, `Init` doesn't have `knowledgeVector` in `SyncSagaMessageInitData` yet (it has `SyncInitData` generic props).
-            // Let's assume standard flow:
-            // 1. Sender says "I have X"
-            // 2. Receiver says "I don't have X. But if I did have Y (ancestor), I'd tell you." 
-            // Problem: Receiver doesn't know X is related to Y without X.
-            // SOLUTION:
-            // The *Sender* must include TJP mappings or we rely on `knowledgeVector` in `Init`?
-            // `SyncSagaMessageInitData_V1` extends `SyncInitData`.
-            // `SyncInitData` has `knowledgeVector`.
-            // If Sender populates `knowledgeVector` in `Init`, Receiver can use keys (TJPs) to look up its own state!
-            // Let's implement Sender populating `Init.knowledgeVector`.
-            // But `SyncSagaCoordinator.startSaga` creates Init.
             // 3. Create Ack Frame
+            if (!sagaIbGib.data) {
+                throw new Error(`(UNEXPECTED) sagaIbGib.data falsy? (E: 24203af4600fb226ae6c1afbde442826)`);
+            }
             const sagaId = sagaIbGib.data.uuid;
             // Create Payload Stone
             const ackData = {
                 sagaId,
                 stage: SyncStage.ack,
-                deltaReqAddrs,
-                pushOfferAddrs,
-                knowledgeVector,
+                deltaRequestAddrInfos,
+                pushOfferInfos,
             };
             if (conflicts?.length > 0) {
                 ackData.conflicts = conflicts;
@@ -926,13 +1014,65 @@ export class SyncSagaCoordinator {
              * we want to push ibgibs to the remote/sender if we have push
              * offers. an ack frame's payloads, if any, are those push offers
              */
-            // let payloadIbGibsDomain: IbGib_V1[] | undefined = await getPushOffers
-            if (pushOfferAddrs.length > 0) {
+            let payloadIbGibsDomain;
+            if (pushOfferInfos.length > 0) {
+                const searchSecondSpaceAddrs = [];
+                payloadIbGibsDomain = [];
+                const domainAddrs = pushOfferInfos.flatMap(x => x.addrs);
+                const resGet = await getFromSpace({ addrs: domainAddrs, space: mySpace, });
+                const resGetRawData = resGet.rawResultIbGib?.data;
+                if (!resGetRawData) {
+                    throw new Error(`(UNEXPECTED) resGet.rawResultIbGib.data falsy? (E: 1a2cc8cb99a1ffa60837e45a8229b826)`);
+                }
+                const addrsNotFound = resGetRawData.addrsNotFound ?? [];
+                const addrsErrored = resGetRawData.addrsErrored ?? [];
+                if (resGet.ibGibs && resGet.ibGibs.length === domainAddrs.length) {
+                    // found all of them
+                    resGet.ibGibs.forEach(x => { payloadIbGibsDomain.push(x); });
+                }
+                else if (resGet.ibGibs && resGet.ibGibs.length > 0) {
+                    // found some of them
+                    resGet.ibGibs.forEach(x => { payloadIbGibsDomain.push(x); });
+                    const foundPlusNotFoundCount = payloadIbGibsDomain.length +
+                        addrsNotFound.length +
+                        addrsErrored.length;
+                    if (foundPlusNotFoundCount === domainAddrs.length) {
+                        // we can still conceivably get the remaining addrs
+                        addrsNotFound.forEach(x => searchSecondSpaceAddrs.push(x));
+                        addrsErrored.forEach(x => searchSecondSpaceAddrs.push(x));
+                    }
+                    else if (addrsNotFound.length === 0 && addrsErrored.length === 0) {
+                        throw new Error(`(UNEXPECTED) found some but not all addrs but addrsNotFound and addrsErrored both empty? (E: ef1b2cf5bab8de2298ec507abe04e826)`);
+                    }
+                    else {
+                        throw new Error(`(UNEXPECTED) found some but not all addrs but addrsNotFound and addrsErrored don't contain the addrs not found? (E: ae9e015109f8c3c3a813da584cd98826)`);
+                    }
+                }
+                else {
+                    // found none of them(?)
+                    console.warn(`${lc} we were expecting all domainAddrs in mySpace (${mySpace.ib}) but we couldn't get all of them. addrsNotFound: ${addrsNotFound ?? []}. addrsErrored: ${addrsErrored ?? []}. Trying temp space (${myTempSpace.ib}). (W: f61908e264f8dddd2e3fb9084463d826)`);
+                    domainAddrs.forEach(x => searchSecondSpaceAddrs.push(x));
+                }
+                if (searchSecondSpaceAddrs.length > 0) {
+                    if (logalot) {
+                        console.log(`${lc} couldn't get all addrs in mySpace (${mySpace.ib}). searchSecondSpaceAddrs: ${searchSecondSpaceAddrs} (I: 233fd954dbd84e51bca02fa8eed5f826)`);
+                    }
+                    const resGet2 = await getFromSpace({ addrs: searchSecondSpaceAddrs, space: myTempSpace, });
+                    if (resGet2.success && resGet2.ibGibs && resGet2.ibGibs.length === searchSecondSpaceAddrs.length) {
+                        // got them all the second try
+                        resGet2.ibGibs.forEach(x => payloadIbGibsDomain.push(x));
+                    }
+                    else {
+                        resGet2.ibGibs?.forEach(x => payloadIbGibsDomain.push(x));
+                        const addrsFailed = domainAddrs.filter(x => !payloadIbGibsDomain.map(pid => getIbGibAddr({ ibGib: pid })).includes(x));
+                        throw new Error(`couldn't get some or all of addrs from either mySpace (${mySpace.ib}) or myTempSpace (${myTempSpace.ib}). addrsFailed: ${addrsFailed} (E: 1394d412c4ffa4dd085f269b43338826)`);
+                    }
+                }
+                // we have now populated payloadIbGibsDomain
             }
             return {
                 frame: ackFrame,
-                // conflictInfos,
-                // payloadIbGibsDomain,
+                payloadIbGibsDomain,
             };
         }
         catch (error) {
@@ -957,7 +1097,7 @@ export class SyncSagaCoordinator {
      *
      * Returns a `Delta` frame.
      */
-    async handleAckFrame({ sagaIbGib, srcGraph, destSpace, tempSpace, metaspace, identity, }) {
+    async handleAckFrame({ sagaIbGib, srcGraph, initDomainGraph, destSpace, tempSpace, metaspace, identity, }) {
         const lc = `${this.lc}[${this.handleAckFrame.name}]`;
         try {
             if (logalot) {
@@ -985,12 +1125,12 @@ export class SyncSagaCoordinator {
                 console.warn(`${lc} Received terminal conflicts from Ack: ${JSON.stringify(terminalConflicts)}`);
                 // Terminal failure. Sender should probably Commit(Fail) or just Abort.
                 // For now, throw to trigger abort.
-                throw new Error(`${lc} Peer reported terminal conflicts. (E: a1b2c3d4e5f6g7h8i9j0k)`);
+                throw new Error(`${lc} Peer reported terminal conflicts. (E: 23a0096ee05a2ccfa89334e8f156b426)`);
             }
-            const optimisticConflicts = conflicts.filter(c => !c.terminal);
+            // at this point, if we have conflicts, they are non-terminal
             const mergeDeltaReqs = []; // Additional requests for merging
-            if (optimisticConflicts.length > 0) {
-                console.log(`${lc} [CONFLICT DEBUG] Processing ${optimisticConflicts.length} optimistic conflicts`);
+            if (conflicts.length > 0) {
+                console.log(`${lc} [CONFLICT DEBUG] Processing ${conflicts.length} non-terminal conflicts`);
                 // We need to resolve these.
                 // Strategy:
                 // 1. Analyze Divergence (Sender vs Receiver)
@@ -1007,7 +1147,7 @@ export class SyncSagaCoordinator {
                 // Or can we send a 'Delta Request' frame?
                 // Standard Saga: Init(Push) -> Ack(Pull Reqs) -> Delta(Push Data).
                 // If Sender needs data, we might need a "Reverse Delta" or "Pull" phase?
-                // Or we just proceed to Delta (sending what Receiver wants), 
+                // Or we just proceed to Delta (sending what Receiver wants),
                 // AND we piggyback our own requests?
                 // OR: We treat the Conflict Resolution as a sub-saga or side-effect?
                 // SIMPLIFICATION for V1:
@@ -1016,138 +1156,134 @@ export class SyncSagaCoordinator {
                 // `peer.pull(addr)`?
                 // Yes! The Coordinator has the `peer`.
                 // Let's analyze and pull immediately.
-                for (const conflict of optimisticConflicts) {
-                    const { timelineAddrs, localAddr: receiverTip, remoteAddr: senderTip } = conflict;
-                    // Sender History
-                    // We need our own history for this timeline.
-                    // We know the 'senderTip' (remoteAddr in Ack).
-                    // Sender should verify it has this tip.
-                    // Compute Diffs
-                    // We need to find `receiverOnly` addrs.
-                    // Receiver sent us `timelineAddrs` (Full History).
-                    const receiverHistorySet = new Set(timelineAddrs);
-                    // We need our execution context's history for this senderTip.
-                    // We can fetch valid 'past' from space.
-                    const resSenderTip = await getFromSpace({ space: destSpace, addr: senderTip });
-                    const senderTipIbGib = resSenderTip.ibGibs?.[0];
-                    if (!senderTipIbGib) {
-                        throw new Error(`${lc} Sender missing its own tip? ${senderTip} (E: 9c8d7e6f5g4h3i2j1k0l)`);
-                    }
-                    // Basic Diff: Find what Receiver has that we don't.
-                    // Actually, we need to traverse OUR past to find commonality.
-                    const senderHistory = [senderTip, ...(senderTipIbGib.rel8ns?.past || [])];
-                    const receiverOnlyAddrs = timelineAddrs.filter(addr => !senderHistory.includes(addr));
-                    if (receiverOnlyAddrs.length > 0) {
-                        console.log(`${lc} [CONFLICT DEBUG] Found ${receiverOnlyAddrs.length} receiver-only frames - need to pull for merge`);
-                        console.log(`${lc} [CONFLICT DEBUG] Receiver-only addrs:`, receiverOnlyAddrs);
-                        // PULL these frames from Peer into Local Space
-                        // (Validation: We trust peer for now / verification happens on put)
-                        for (const addr of receiverOnlyAddrs) {
-                            console.error(`${lc} [CONFLICT DEBUG] NOT IMPLEMENTED (E: e6bf1a9d2758c469bb2f97514062d826)`);
-                        }
-                        // Compute DELTA dependencies for each receiver-only frame
-                        // Find LCA to determine what dependencies we already have
-                        const lcaAddr = timelineAddrs.find(addr => senderHistory.includes(addr));
-                        console.log(`${lc} [CONFLICT DEBUG] LCA: ${lcaAddr || 'NONE'}`);
-                        const skipAddrsSet = new Set();
-                        if (lcaAddr) {
-                            try {
-                                const lcaRes = await getFromSpace({ addr: lcaAddr, space: destSpace });
-                                const lcaIbGib = lcaRes.ibGibs?.[0];
-                                if (lcaIbGib) {
-                                    const lcaDeps = await getDependencyGraph({ ibGib: lcaIbGib, space: destSpace });
-                                    if (lcaDeps)
-                                        Object.keys(lcaDeps).forEach(a => skipAddrsSet.add(a));
-                                    console.log(`${lc} [CONFLICT DEBUG] LCA deps to skip: ${skipAddrsSet.size}`);
-                                }
-                            }
-                            catch (e) {
-                                console.warn(`${lc} Error getting LCA deps: ${extractErrorMsg(e)}`);
-                            }
-                        }
-                        // For each receiver-only frame, get its DELTA dependency graph (minus LCA deps)
-                        for (const addr of receiverOnlyAddrs) {
-                            // Add the frame itself first
-                            if (!mergeDeltaReqs.includes(addr)) {
-                                mergeDeltaReqs.push(addr);
-                            }
-                            // Get the frame's delta dependencies (skip LCA's deps)
-                            try {
-                                const frameRes = await getFromSpace({ addr, space: destSpace });
-                                const frameIbGib = frameRes.ibGibs?.[0];
-                                if (frameIbGib) {
-                                    // Get dependency graph, skipping all LCA dependencies
-                                    const frameDeltaDeps = await getDependencyGraph({
-                                        ibGib: frameIbGib,
-                                        space: destSpace,
-                                        skipAddrs: Array.from(skipAddrsSet), // Skip entire LCA dep graph
-                                    });
-                                    if (frameDeltaDeps) {
-                                        // Add all delta dependencies (Object.keys gives us the addresses)
-                                        Object.keys(frameDeltaDeps).forEach(depAddr => {
-                                            if (!mergeDeltaReqs.includes(depAddr) && !skipAddrsSet.has(depAddr)) {
-                                                mergeDeltaReqs.push(depAddr);
-                                            }
-                                        });
-                                    }
-                                }
-                            }
-                            catch (depError) {
-                                console.warn(`${lc} [CONFLICT DEBUG] Error getting delta deps for ${addr}: ${extractErrorMsg(depError)}`);
-                            }
-                        }
-                        console.log(`${lc} [CONFLICT DEBUG] Total merge requests (frames + delta deps): ${mergeDeltaReqs.length}`);
-                    }
-                    else {
-                        console.log(`${lc} [CONFLICT DEBUG] No receiver-only frames found for this conflict`);
-                    }
+                for (const conflict of conflicts) {
+                    // todo: integrate conflict strategies into this point...this whole block needs to be redone, but I want to check the fast-forward/backward simpler case tests first
+                    throw new Error(`conflicts not (re)implemented yet (E: 3b7d0819f83842a6de3ae988819bc826)`);
+                    // const { timelineAddrs, localAddr: receiverTip, remoteAddr: senderTip } = conflict;
+                    // // Sender History
+                    // // We need our own history for this timeline.
+                    // // We know the 'senderTip' (remoteAddr in Ack).
+                    // // Sender should verify it has this tip.
+                    // // Compute Diffs
+                    // // We need to find `receiverOnly` addrs.
+                    // // Receiver sent us `timelineAddrs` (Full History).
+                    // const receiverHistorySet = new Set(timelineAddrs);
+                    // // We need our execution context's history for this senderTip.
+                    // // We can fetch valid 'past' from space.
+                    // const resSenderTip = await getFromSpace({ space: destSpace, addr: senderTip });
+                    // const senderTipIbGib = resSenderTip.ibGibs?.[0];
+                    // if (!senderTipIbGib) { throw new Error(`${lc} Sender missing its own tip? ${senderTip} (E: 832f3804645878869ee3c13714366726)`); }
+                    // // Basic Diff: Find what Receiver has that we don't.
+                    // // Actually, we need to traverse OUR past to find commonality.
+                    // const senderHistory = [senderTip, ...(senderTipIbGib.rel8ns?.past || [])];
+                    // const receiverOnlyAddrs = timelineAddrs.filter(addr => !senderHistory.includes(addr));
+                    // if (receiverOnlyAddrs.length > 0) {
+                    //     console.log(`${lc} [CONFLICT DEBUG] Found ${receiverOnlyAddrs.length} receiver-only frames - need to pull for merge`);
+                    //     console.log(`${lc} [CONFLICT DEBUG] Receiver-only addrs:`, receiverOnlyAddrs);
+                    //     // PULL these frames from Peer into Local Space
+                    //     // (Validation: We trust peer for now / verification happens on put)
+                    //     for (const addr of receiverOnlyAddrs) {
+                    //         console.error(`${lc} [CONFLICT DEBUG] NOT IMPLEMENTED (E: e6bf1a9d2758c469bb2f97514062d826)`);
+                    //     }
+                    //     // Compute DELTA dependencies for each receiver-only frame
+                    //     // Find LCA to determine what dependencies we already have
+                    //     const lcaAddr = timelineAddrs.find(addr => senderHistory.includes(addr));
+                    //     console.log(`${lc} [CONFLICT DEBUG] LCA: ${lcaAddr || 'NONE'}`);
+                    //     const skipAddrsSet = new Set<string>();
+                    //     if (lcaAddr) {
+                    //         try {
+                    //             const lcaRes = await getFromSpace({ addr: lcaAddr, space: destSpace });
+                    //             const lcaIbGib = lcaRes.ibGibs?.[0];
+                    //             if (lcaIbGib) {
+                    //                 const lcaDeps = await getDependencyGraph({ ibGib: lcaIbGib, space: destSpace });
+                    //                 if (lcaDeps) Object.keys(lcaDeps).forEach(a => skipAddrsSet.add(a));
+                    //                 console.log(`${lc} [CONFLICT DEBUG] LCA deps to skip: ${skipAddrsSet.size}`);
+                    //             }
+                    //         } catch (e) {
+                    //             console.warn(`${lc} Error getting LCA deps: ${extractErrorMsg(e)}`);
+                    //         }
+                    //     }
+                    //     // For each receiver-only frame, get its DELTA dependency graph (minus LCA deps)
+                    //     for (const addr of receiverOnlyAddrs) {
+                    //         // Add the frame itself first
+                    //         if (!mergeDeltaReqs.includes(addr)) {
+                    //             mergeDeltaReqs.push(addr);
+                    //         }
+                    //         // Get the frame's delta dependencies (skip LCA's deps)
+                    //         try {
+                    //             const frameRes = await getFromSpace({ addr, space: destSpace });
+                    //             const frameIbGib = frameRes.ibGibs?.[0];
+                    //             if (frameIbGib) {
+                    //                 // Get dependency graph, skipping all LCA dependencies
+                    //                 const frameDeltaDeps = await getDependencyGraph({
+                    //                     ibGib: frameIbGib,
+                    //                     space: destSpace,
+                    //                     skipAddrs: Array.from(skipAddrsSet), // Skip entire LCA dep graph
+                    //                 });
+                    //                 if (frameDeltaDeps) {
+                    //                     // Add all delta dependencies (Object.keys gives us the addresses)
+                    //                     Object.keys(frameDeltaDeps).forEach(depAddr => {
+                    //                         if (!mergeDeltaReqs.includes(depAddr) && !skipAddrsSet.has(depAddr)) {
+                    //                             mergeDeltaReqs.push(depAddr);
+                    //                         }
+                    //                     });
+                    //                 }
+                    //             }
+                    //         } catch (depError) {
+                    //             console.warn(`${lc} [CONFLICT DEBUG] Error getting delta deps for ${addr}: ${extractErrorMsg(depError)}`);
+                    //         }
+                    //     }
+                    //     console.log(`${lc} [CONFLICT DEBUG] Total merge requests (frames + delta deps): ${mergeDeltaReqs.length}`);
+                    // } else {
+                    //     console.log(`${lc} [CONFLICT DEBUG] No receiver-only frames found for this conflict`);
+                    // }
                 }
-                console.log(`${lc} [CONFLICT DEBUG] Finished processing ${optimisticConflicts.length} conflicts. mergeDeltaReqs: ${mergeDeltaReqs.length}`);
+                console.log(`${lc} [CONFLICT DEBUG] Finished processing ${conflicts.length} conflicts. mergeDeltaReqs: ${mergeDeltaReqs.length}`);
             }
             else {
                 console.log(`${lc} [CONFLICT DEBUG] No optimistic conflicts to process`);
             }
             // 2. Prepare Delta Payload (What Receiver Requesting + Our Conflict Logic)
-            const deltaReqAddrs = ackData.deltaReqAddrs || [];
-            const pushOfferAddrs = ackData.pushOfferAddrs || [];
+            const deltaReqAddrs = ackData.deltaRequestAddrInfos || [];
+            const pushOfferAddrs = ackData.pushOfferInfos || [];
             // 1. Process Push Offers (Pull Requests) (Naive: Accept all if missing)
             const pullReqAddrs = [];
             for (const addr of pushOfferAddrs) {
-                const existing = srcGraph[addr] || (await getFromSpace({ addr, space: destSpace })).ibGibs?.[0];
-                if (!existing) {
-                    pullReqAddrs.push(addr);
-                }
+                // const existing = srcGraph[addr] || (await getFromSpace({ addr, space: destSpace })).ibGibs?.[0];
+                // if (!existing) {
+                //     pullReqAddrs.push(addr);
+                // }
             }
             // 2. Process Delta Requests (Push Payload)
             // [NEW] Smart Diff: Use knowledgeVector to skip dependencies
+            // const useThisFunction = getDeltaDependencyGraph({ ibGibAddr: '', latestCommonFrameAddr: '', space: })
             const skipAddrs = new Set();
             if (ackData.knowledgeVector) {
                 Object.values(ackData.knowledgeVector).forEach(addrs => {
-                    addrs.forEach(a => skipAddrs.add(a));
+                    // addrs.forEach(a => skipAddrs.add(a));
                 });
             }
             const payloadIbGibs = [];
             // Gather all tips to sync first
             const tipsToSync = [];
             for (const addr of deltaReqAddrs) {
-                let ibGib = srcGraph[addr];
-                if (!ibGib) {
-                    const res = await getFromSpace({ addr, space: destSpace });
-                    if (res.ibGibs && res.ibGibs.length > 0) {
-                        ibGib = res.ibGibs[0];
-                    }
-                }
-                if (ibGib) {
-                    tipsToSync.push(ibGib);
-                }
-                else {
-                    throw new Error(`${lc} Requested addr not found: ${addr} (E: d41d59cff4a887f6414c3e92eabd8e26)`);
-                }
+                // let ibGib = srcGraph[addr];
+                // if (!ibGib) {
+                //     const res = await getFromSpace({ addr, space: destSpace });
+                //     if (res.ibGibs && res.ibGibs.length > 0) {
+                //         ibGib = res.ibGibs[0];
+                //     }
+                // }
+                // if (ibGib) {
+                //     tipsToSync.push(ibGib);
+                // } else {
+                //     throw new Error(`${lc} Requested addr not found: ${addr} (E: d41d59cff4a887f6414c3e92eabd8e26)`);
+                // }
             }
             // Calculate Dependency Graph for ALL tips, effectively utilizing common history
             // Pass skipAddrs to `getDependencyGraph` or gather manually.
             // `getDependencyGraph` takes a single ibGib.
-            // We can optimize by doing it for each tip and unioning the result? 
+            // We can optimize by doing it for each tip and unioning the result?
             // Or `graph-helper` could support `ibGibs: []`. It currently takes `ibGib`.
             // We will loop.
             const allDepsSet = new Set();
@@ -1219,7 +1355,8 @@ export class SyncSagaCoordinator {
                 payloadIbGibsControl.push(identity);
             }
             // return { frame: deltaFrame, payloadIbGibsControl, payloadIbGibsDomain: payloadIbGibs };
-            return { frame: deltaFrame, payloadIbGibsDomain: payloadIbGibs };
+            // return { frame: deltaFrame, payloadIbGibsDomain: payloadIbGibs };
+            throw new Error(`not implemented (E: 62e1e2a408e8bfa2982b2f87e8843826)`);
         }
         catch (error) {
             console.error(`${lc} ${extractErrorMsg(error)}`);
@@ -1255,7 +1392,7 @@ export class SyncSagaCoordinator {
             throw new Error(`${lc} Invalid delta frame: deltaData.stage !== SyncStage.delta (E: 0c28c8d8f08a4421b8344e6727271421)`);
         }
         if (logalot) {
-            console.log(`${lc} deltaData: ${pretty(deltaData)} (I: 8d7e6f5g4h3i2j1k0l9m)`);
+            console.log(`${lc} deltaData: ${pretty(deltaData)} (I: a76008681df458cfbcdc4848f825a826)`);
         }
         console.log(`${lc} [CONFLICT DEBUG] deltaData.payloadAddrs count: ${deltaData.payloadAddrs?.length || 0}`);
         const payloadAddrs = deltaData.payloadAddrs || [];
@@ -1264,8 +1401,8 @@ export class SyncSagaCoordinator {
         // 1. Process Received Payload (Ingest)
         const receivedPayloadIbGibs = [];
         if (payloadAddrs.length > 0) {
-            // We use `payloadAddrs` as the manifest. 
-            // The ACTUAL collection of ibGibs should be available via `getFromSpace` 
+            // We use `payloadAddrs` as the manifest.
+            // The ACTUAL collection of ibGibs should be available via `getFromSpace`
             // assuming the "Transport" layer put them there implicitly?
             // OR, if we are local-only, we just get them.
             // The `handleDeltaFrame` contract assumes data is reachable in `space`.
@@ -1290,7 +1427,7 @@ export class SyncSagaCoordinator {
             // Get the requested ibGib
             let ibGib = srcGraph[addr];
             if (!ibGib) {
-                const res = await getFromSpace({ addr, space: destSpace }); // Query from destSpace  
+                const res = await getFromSpace({ addr, space: destSpace }); // Query from destSpace
                 if (res.ibGibs && res.ibGibs.length > 0) {
                     ibGib = res.ibGibs[0];
                 }
@@ -1376,7 +1513,7 @@ export class SyncSagaCoordinator {
                     console.log(`${lc} [CONFLICT DEBUG] ReceiverTip found in tempSpace: ${!!resRecTip.ibGibs?.[0]}`);
                     if (resRecTip.success && resRecTip.ibGibs?.[0]) {
                         // We have the tip!
-                        // Do we have the full history? 
+                        // Do we have the full history?
                         // `mergeDivergentTimelines` in `conflict-optimistic` will attempt to fetch history.
                         // If we just ingested the missing pieces, `getFromSpace` inside `merge` should succeed.
                         // Perform Merge!
@@ -1420,9 +1557,9 @@ export class SyncSagaCoordinator {
                 payloadAddrs: outgoingPayload.map(p => getIbGibAddr({ ibGib: p })),
                 requests: hasMyRequests ? myRequests : undefined,
                 proposeCommit: !hasMyRequests // If we are sending data but have no requests, we VALIDATE PROPOSAL?
-                // Wait. If we send data, we are NOT committing yet. 
+                // Wait. If we send data, we are NOT committing yet.
                 // We are sending data. The OTHER side must ingest it.
-                // So proposeCommit = true? 
+                // So proposeCommit = true?
                 // "Here is the data. I'm done. If you are good, let's commit."
                 // Yes.
             };
@@ -1448,7 +1585,8 @@ export class SyncSagaCoordinator {
                 payloadIbGibsControl.push(identity);
             }
             // return { frame: deltaFrame, payloadIbGibsControl, payloadIbGibsDomain: outgoingPayload };
-            return { frame: deltaFrame, payloadIbGibsDomain: outgoingPayload };
+            // return { frame: deltaFrame, payloadIbGibsDomain: outgoingPayload };
+            throw new Error(`not implemented (E: 2b38a8afb6d84efcee5ab51673387826)`);
         }
         else {
             // We have nothing to send.
@@ -1477,7 +1615,8 @@ export class SyncSagaCoordinator {
                     commitCtrlPayloads.push(identity);
                 }
                 // return { frame: commitFrame, payloadIbGibsControl: commitCtrlPayloads };
-                return { frame: commitFrame, };
+                // return { frame: commitFrame, };
+                throw new Error(`not implemented (E: dda1ddc63fdcadff06653298e0d04826)`);
             }
             else {
                 // peer did NOT propose commit (maybe they just sent data/requests and didn't ready flag).
@@ -1531,7 +1670,8 @@ export class SyncSagaCoordinator {
                         commitCtrlPayloads2.push(identity);
                     }
                     // return { frame: commitFrame, payloadIbGibsControl: commitCtrlPayloads2 };
-                    return { frame: commitFrame, };
+                    // return { frame: commitFrame, };
+                    throw new Error(`not implemented (E: 27514878585889e531ef21f1abbef826)`);
                 }
                 // Build control payloads for delta propose
                 const deltaCtrlPayloads = [deltaFrame, deltaStone];
@@ -1539,7 +1679,8 @@ export class SyncSagaCoordinator {
                     deltaCtrlPayloads.push(identity);
                 }
                 // return { frame: deltaFrame, payloadIbGibsControl: deltaCtrlPayloads };
-                return { frame: deltaFrame, };
+                // return { frame: deltaFrame, };
+                throw new Error(`not implemented (E: ff35584696b6fcb3ad6dd7c5cade2f26)`);
             }
         }
     }
@@ -1559,7 +1700,8 @@ export class SyncSagaCoordinator {
         if (logalot) {
             console.log(`${lc} Peer committed. Finalizing saga locally. Saga Complete.`);
         }
-        return null;
+        // return { responseWasNull: true };
+        throw new Error(`not implemented (E: 4d7f878bcc45ad3dd9c4b8573f3aa826)`);
     }
     // #endregion Handlers
     async createSyncMsgStone({ data, localSpace, metaspace, }) {
@@ -1633,7 +1775,7 @@ export class SyncSagaCoordinator {
                 if (sessionIdentity) {
                     rel8nInfos.push({ rel8nName: 'identity', ibGibs: [sessionIdentity], });
                 }
-                // remove the existing sync msg stones' addrs 
+                // remove the existing sync msg stones' addrs
                 if (!prevSagaIbGib.rel8ns) {
                     throw new Error(`(UNEXPECTED) prevSagaIbGib.rel8ns falsy? (E: 81375841aff85b1e48ea42ca218e6826)`);
                 }