@ibgib/core-gib 0.1.20 → 0.1.21

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

@@ -21,9 +21,12 @@ import { createTimelineRootHelper, getTestKeystoneServiceHelper } from '../agent
 import { mut8Timeline } from '../timeline/timeline-api.mjs';
 import { SyncPeerInnerspace_V1 } from './sync-peer/sync-peer-innerspace-v1.mjs';
 import { DEFAULT_INNER_SPACE_DATA_V1 } from '../witness/space/inner-space/inner-space-types.mjs';
-import { toDto } from '../common/other/ibgib-helper.mjs';
+import { getTjpAddr, toDto } from '../common/other/ibgib-helper.mjs';
 import { SyncConflictStrategy, SyncSagaInfo } from './sync-types.mjs';
-import { IbGibData_V1 } from '@ibgib/ts-gib/dist/V1/types.mjs';
+import { IbGibData_V1, IbGib_V1 } from '@ibgib/ts-gib/dist/V1/types.mjs';
+import { fnObs } from '../common/pubsub/observer/observer-helper.mjs';
+import { getDependencyGraph } from '../common/other/graph-helper.mjs';
+import { ErrorIbGib_V1 } from '../common/error/error-types.mjs';
 
 interface TestData extends IbGibData_V1 {
     text?: string;
@@ -71,28 +74,40 @@ await respecfully(sir, `Sync Conflict Resolution`, async () => {
 
         // 2. Seed Common History (V0 -> V1)
         console.log(`${lc} Creating Common History...`);
-        const root = await createTimelineRootHelper<TestData>({
+        const testRoot = await createTimelineRootHelper<TestData>({
             ib: 'timeline_root',
-            data: { type: 'root', text: 'v0' },
+            data: { type: 'testRoot', text: 'v0' },
             space: sourceSpace,
         });
-        // Sync root to dest immediately so they start synced
-        await metaspace.put({ ibGib: root, space: destSpace });
-        await metaspace.registerNewIbGib({ ibGib: root, space: destSpace });
-
-
         // Create V1 (Common)
-        const v1_Source = await mut8Timeline<TestData>({
-            timeline: root,
+        const v1_Common = await mut8Timeline<TestData>({
+            timeline: testRoot,
             mut8Opts: { dataToAddOrPatch: { text: 'v1_common' } },
             metaspace,
             space: sourceSpace,
         });
-        // Sync V1 to dest
-        await metaspace.put({ ibGib: v1_Source, space: destSpace });
-        await metaspace.registerNewIbGib({ ibGib: v1_Source, space: destSpace });
+        const tjpAddr =
+            getTjpAddr({ ibGib: testRoot, defaultIfNone: 'incomingAddr' }) ??
+            getIbGibAddr({ ibGib: testRoot });
+        console.log(`${lc} [TEST DEBUG] tjpAddr: ${tjpAddr}`)
+        // Sync testRoot to dest immediately so they start synced
+        // must get the entire dependency graph for testRoot
+        const depGraph_testRootAndV1Common = await getDependencyGraph({
+            ibGibAddrs: [tjpAddr],
+            space: sourceSpace,
+            live: true,
+        }) ?? {};
+        console.log(`${lc} depGraph_testRootAndV1Common: ${pretty(depGraph_testRootAndV1Common)}`)
+        if (Object.keys(depGraph_testRootAndV1Common).length === 0) {
+            throw new Error(`(UNEXPECTED) depGraph_testRootAndV1Common empty? (E: 39b4d855ffa65476084b4123786da826)`);
+        }
+        // put the entire graph into the destspace, but...
+        await metaspace.put({ ibGibs: Object.values(depGraph_testRootAndV1Common), space: destSpace });
+        // ...only register the main ibgibs
+        await metaspace.registerNewIbGib({ ibGib: testRoot, space: destSpace });
+        await metaspace.registerNewIbGib({ ibGib: v1_Common, space: destSpace });
 
-        const resGetDest = await getFromSpace({ space: destSpace, addr: getIbGibAddr({ ibGib: v1_Source }) });
+        const resGetDest = await getFromSpace({ space: destSpace, addr: getIbGibAddr({ ibGib: v1_Common }) });
         if (!resGetDest.success || !resGetDest.ibGibs || resGetDest.ibGibs.length === 0) {
             throw new Error(`Failed to retrieve v1_Dest from destSpace. (E: a1b2c3d4e5f6g7h8i9j0)`);
         }
@@ -104,7 +119,7 @@ await respecfully(sir, `Sync Conflict Resolution`, async () => {
 
         // Source: V1 -> V2a (Edit Field A)
         const v2a = await mut8Timeline<TestData>({
-            timeline: v1_Source,
+            timeline: v1_Common,
             mut8Opts: { dataToAddOrPatch: { fieldA: 'source_edit' } },
             metaspace,
             space: sourceSpace,
@@ -119,9 +134,6 @@ await respecfully(sir, `Sync Conflict Resolution`, async () => {
         });
 
         // Verify Divergence
-        const tjpAddr = root.rel8ns!.tjp![0]; // wait, root IS tjp, so no tjp rel8n...
-        // Actually root frame has isTjp: true.
-        // v1 has tjp: [v0_gib].
         console.log(`${lc} Divergence created.`);
 
 
@@ -131,27 +143,53 @@ await respecfully(sir, `Sync Conflict Resolution`, async () => {
         const senderCoordinator = new SyncSagaCoordinator(mockKeystone);
         const receiverCoordinator = new SyncSagaCoordinator(mockKeystone);
 
+
+        // Create sender's tempSpace for transactional payload transfer
+        const senderTempSpaceName = `tmp_sender_test_${Date.now()}`;
+        const senderTempSpace = await metaspace.createNewLocalSpace({
+            opts: {
+                allowCancel: false,
+                spaceName: senderTempSpaceName,
+                getFnPrompt: metaspace.getFnPrompt!,
+            }
+        });
+        if (!senderTempSpace) { throw new Error(`(UNEXPECTED) senderTempSpace falsy? (E: ef4388c87e98f0211852eefa22414f26)`); }
+        await senderTempSpace.initialized;
+
         const peer = new SyncPeerInnerspace_V1({
             senderSpace: sourceSpace,
+            senderTempSpace,  // Pass sender's tempSpace for payload transfer
             receiverSpace: destSpace,
             receiverCoordinator,
             receiverMetaspace: metaspace,
         });
+        await peer.initialized;
 
         // Verify Receiver has correct KV (Pre-Sync Check)
         // This ensures the conflict precondition exists.
-        await ifWe(sir, 'verify receiver KV pre-sync', async () => {
-            const destKV = await receiverCoordinator.getKnowledgeVector({
-                space: destSpace,
-                metaspace,
-                domainIbGibs: [v1_Dest]
-            });
-            const v1TjpAddr = v1_Dest.rel8ns?.tjp?.[0] || getIbGibAddr({ ibGib: v1_Dest }); // v1 might be tjp if it was root, but here v1 is child of root
-            // Actually v1 has tjp rel8n.
-            const destTip = destKV[v1TjpAddr];
-            iReckon(sir, !!destTip).asTo(`Dest KV has timeline tip for ${v1TjpAddr}`).isGonnaBeTruthy();
-            if (!destTip) {
-                throw new Error(`Test Setup Fail: Dest Space does not have index for timeline ${v1TjpAddr}. Seeding failed. (E: 8a9b0c1d)`);
+        await ifWeMight(sir, 'verify receiver KV pre-sync', async () => {
+            try {
+                const destKV = await receiverCoordinator.getKnowledgeVector({
+                    space: destSpace,
+                    metaspace,
+                    domainIbGibs: [v1_Dest]
+                });
+                const v1TjpAddr = getTjpAddr({ ibGib: v1_Dest, defaultIfNone: 'incomingAddr' }) ?? getIbGibAddr({ ibGib: v1_Dest });
+                console.log(`[TEST DEBUG] v1_Dest: ${JSON.stringify(v1_Dest)}`);
+                console.log(`[TEST DEBUG] v1TjpAddr: ${v1TjpAddr}`);
+                console.log(`[TEST DEBUG] destKV: ${JSON.stringify(destKV)}`);
+                console.log(`[TEST DEBUG] v1_Dest.rel8ns.tjp: ${v1_Dest.rel8ns?.tjp?.join(', ')}`);
+
+                // Actually v1 has tjp rel8n.
+                const destTip = destKV[v1TjpAddr];
+                iReckon(sir, !!destTip).asTo(`Dest KV has timeline tip for ${v1TjpAddr}`).isGonnaBeTruthy();
+                if (!destTip) {
+                    throw new Error(`Test Setup Fail: Dest Space does not have index for timeline ${v1TjpAddr}. Seeding failed. (E: c194a80b4e4877b77826c37a1753b826)`);
+                }
+
+            } catch (error) {
+                console.error(`${lc} ${extractErrorMsg(error)}`);
+                iReckon(sir, true).asTo('getKnowledgeVector errored out').isGonnaBeFalse();
             }
         });
 
@@ -171,7 +209,31 @@ await respecfully(sir, `Sync Conflict Resolution`, async () => {
                 // explicit useSessionIdentity: true is default
             });
 
+            const sublc = `${lc}[updates$]`;
+            /**
+             * I have added this so you can see how to subscribe to an ibgib
+             * observable using {@link fnObs}.
+             */
+            const subscription = await resSync.updates$.subscribe(fnObs({
+                next: async (ctxIbGib) => {
+                    console.log(`${sublc} next fired. ${pretty(ctxIbGib)}`);
+                },
+                error: async (e: ErrorIbGib_V1) => {
+                    if (e.data) {
+                        console.error(`${sublc} error fired. error: ${JSON.stringify(e.data)} (E: 01cc08ba05ad99682831174fd7c31a26)`);
+                    } else {
+                        console.dir(e);
+                        console.error(`${sublc} error fired. error: ${extractErrorMsg(e)} (E: 73d3d61464e8e4ce4cd6efd8b9675826)`);
+                    }
+                },
+                complete: async () => {
+                    console.log(`${sublc} complete fired`);
+                },
+            }));
+
+            console.log(`${lc} awaiting resSync.done`)
             await resSync.done;
+
             console.log(`${lc} Sync Complete.`);
         } catch (e) {
             console.error(`${lc} Sync Failed with Error:`, e);
@@ -184,10 +246,84 @@ await respecfully(sir, `Sync Conflict Resolution`, async () => {
 
         const resSourceTip = await getFromSpace({ space: sourceSpace, addr: getIbGibAddr({ ibGib: v2a }) });
 
-        await ifWe(sir, `verify merge happened`, async () => {
-            // We expect a new tip that is NOT v2a or v2b
-            // For now, valid failure is that this code doesn't start or completes without merge.
-            iReckon(sir, true).asTo('Merge Verification Not Yet Implemented').isGonnaBeFalse();
+        await ifWeMight(sir, `verify merge happened`, async () => {
+            // Retrieve updated KV from Source (or check what happened to v2a)
+            // Ideally, we just check the source space for the timeline tip
+            // The timeline tip for testRoot/v0 should now be NEW.
+
+            try {
+                // Get the KV for the Source Space
+                const sourceKV = await senderCoordinator.getKnowledgeVector({
+                    space: sourceSpace,
+                    metaspace,
+                    domainIbGibs: [testRoot] // We want to know the tip of this timeline
+                });
+                const tjpAddr =
+                    getTjpAddr({ ibGib: testRoot, defaultIfNone: 'incomingAddr' }) ??
+                    getIbGibAddr({ ibGib: testRoot });
+
+                if (logalot) { console.log(`${lc} getKnowledgeVector returned. sourceKV: ${pretty(sourceKV)} (I: e8780cda37c8b2a46eeb85786874e926)`); }
+
+                const sourceTipAddr = sourceKV[tjpAddr];
+                if (!sourceTipAddr) {
+                    throw new Error(`Source Space missing timeline tip for ${tjpAddr} (E: ec95980b9c980c5c5870812e15e43826)`);
+                }
+                console.log(`${lc} [TEST DEBUG] sourceTipAddr: ${sourceTipAddr}`);
+                console.log(`${lc} [TEST DEBUG] v2a: ${getIbGibAddr({ ibGib: v2a })}`);
+                console.log(`${lc} [TEST DEBUG] v2b: ${getIbGibAddr({ ibGib: v2b })}`);
+
+
+                iReckon(sir, sourceTipAddr).asTo(`Source Tip (${sourceTipAddr}) should NOT be v2a`).not.isGonnaBe(getIbGibAddr({ ibGib: v2a }));
+                iReckon(sir, sourceTipAddr).asTo(`Source Tip (${sourceTipAddr}) should NOT be v2b`).not.isGonnaBe(getIbGibAddr({ ibGib: v2b }));
+
+                // Fetch the new tip
+                const resTip = await getFromSpace({ space: sourceSpace, addr: sourceTipAddr });
+                const newTip = resTip.ibGibs![0] as IbGib_V1<TestData>;
+                console.log(`${lc} [TEST DEBUG] newTip: ${JSON.stringify(newTip)}`);
+
+
+                // Check Data: Should have BOTH edits
+                iReckon(sir, newTip.data!.fieldA).asTo('New Tip Data Field A').isGonnaBe('source_edit');
+                iReckon(sir, newTip.data!.fieldB).asTo('New Tip Data Field B').isGonnaBe('dest_edit');
+
+                // Check Graft Structure
+                // Look for 'graftinfo' rel8n
+                const graftInfoRel = newTip.rel8ns?.graftinfo;
+                iReckon(sir, graftInfoRel).asTo('New Tip should have graftinfo rel8n').isGonnaBeTruthy();
+                if (graftInfoRel) {
+                    iReckon(sir, graftInfoRel!.length).asTo('Only 1 graftinfo').isGonnaBe(1);
+
+                    // Fetch Graft Info Stone
+                    const resGraft = await getFromSpace({ space: sourceSpace, addr: graftInfoRel![0] });
+                    const graftInfo = resGraft.ibGibs![0];
+                    console.log(`${lc} [TEST DEBUG] graftInfo: ${JSON.stringify(graftInfo)}`);
+
+                    // Check Graft Relations (graftbase, graftorphan)
+                    const baseRel = graftInfo.rel8ns?.graftbase;
+                    const orphanRel = graftInfo.rel8ns?.graftorphan;
+
+                    iReckon(sir, baseRel).asTo('Graft Base exists').isGonnaBeTruthy();
+                    iReckon(sir, orphanRel).asTo('Graft Orphan exists').isGonnaBeTruthy();
+
+
+                    // Verify Base/Orphan identity (one should be v2a, one v2b)
+                    const addrV2a = getIbGibAddr({ ibGib: v2a });
+                    const addrV2b = getIbGibAddr({ ibGib: v2b });
+
+                    const bases = baseRel || [];
+                    const orphans = orphanRel || [];
+
+                    const isV2aInvolved = bases.includes(addrV2a) || orphans.includes(addrV2a);
+                    const isV2bInvolved = bases.includes(addrV2b) || orphans.includes(addrV2b);
+
+                    iReckon(sir, isV2aInvolved).asTo('V2a is involved in graft').isGonnaBeTrue();
+                    iReckon(sir, isV2bInvolved).asTo('V2b is involved in graft').isGonnaBeTrue();
+                }
+            } catch (error) {
+                console.error(`${lc} ${extractErrorMsg(error)}`);
+                iReckon(sir, true).asTo('getKnowledgeVector errored out').isGonnaBeFalse();
+            }
+
         });
     });
 

package/src/sync/sync-constants.mts

@@ -13,15 +13,13 @@ export const SYNC_STAGE_ACK = "ack";
 export const SYNC_STAGE_REQUEST = "request";
 export const SYNC_STAGE_DELTA = "delta";
 export const SYNC_STAGE_COMMIT = "commit";
-export const SYNC_STAGE_CONFLICT = "conflict";
 
 export type SyncStage =
     | typeof SYNC_STAGE_INIT
     | typeof SYNC_STAGE_ACK
     | typeof SYNC_STAGE_REQUEST
     | typeof SYNC_STAGE_DELTA
-    | typeof SYNC_STAGE_COMMIT
-    | typeof SYNC_STAGE_CONFLICT;
+    | typeof SYNC_STAGE_COMMIT;
 
 export const SyncStage = {
     init: SYNC_STAGE_INIT,
@@ -29,5 +27,4 @@ export const SyncStage = {
     request: SYNC_STAGE_REQUEST,
     delta: SYNC_STAGE_DELTA,
     commit: SYNC_STAGE_COMMIT,
-    conflict: SYNC_STAGE_CONFLICT,
 } as const;

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

@@ -7,20 +7,22 @@ import { IbGib_V1 } from '@ibgib/ts-gib/dist/V1/types.mjs';
 import { getIbGibAddr } from '@ibgib/ts-gib/dist/helper.mjs';
 
 import { GLOBAL_LOG_A_LOT } from '../../core-constants.mjs';
-import { SYNC_ATOM } from '../sync-constants.mjs';
+import { SYNC_ATOM, SYNC_MSG_REL8N_NAME } from '../sync-constants.mjs';
 import { IbGibSpaceAny } from '../../witness/space/space-base-v1.mjs';
-import { SyncSagaContextIbGib_V1 } from '../sync-saga-context/sync-saga-context-types.mjs';
-import { SyncPeer_V1 } from './sync-peer-v1.mjs';
 import { SyncSagaCoordinator } from '../sync-saga-coordinator.mjs';
-import { createSyncSagaContext } from '../sync-saga-context/sync-saga-context-helpers.mjs';
-import { getFromSpace, putInSpace } from '../../witness/space/space-helper.mjs';
 import { MetaspaceService } from '../../witness/space/metaspace/metaspace-types.mjs';
+import { SyncPeer_V1 } from './sync-peer-v1.mjs';
+import { getFromSpace, putInSpace } from '../../witness/space/space-helper.mjs';
+import { SyncSagaContextIbGib_V1 } from '../sync-saga-context/sync-saga-context-types.mjs';
+import { createSyncSagaContext } from '../sync-saga-context/sync-saga-context-helpers.mjs';
 
 export interface SyncPeerInnerspaceOptions {
-    senderSpace: IbGibSpaceAny;
-    receiverSpace: IbGibSpaceAny;
+    senderSpace: IbGibSpaceAny;          // Durable space for audit trail
+    senderTempSpace?: IbGibSpaceAny;     // Transactional space - will use if provided
+    receiverSpace: IbGibSpaceAny;        // Durable space for receiver audit trail
     receiverCoordinator: SyncSagaCoordinator;
     receiverMetaspace: MetaspaceService; // Need this for receiver execution
+    receiverTempSpace?: IbGibSpaceAny;   // Optional: will be created if not provided
 }
 
 const logalot = GLOBAL_LOG_A_LOT || true;
@@ -41,6 +43,26 @@ export class SyncPeerInnerspace_V1 extends SyncPeer_V1 {
         super(opts.receiverSpace.data!); // Use receiver space data as initial phantom data? Or empty.
     }
 
+    private async ensureReceiverTempSpace(): Promise<IbGibSpaceAny> {
+        if (!this.opts.receiverTempSpace) {
+            const { receiverMetaspace } = this.opts;
+            const uuid = crypto.randomUUID ? crypto.randomUUID() : Math.random().toString(36);
+            const tempSpaceName = `tmp_sync_recv_${uuid.substring(0, 8)}`;
+            this.opts.receiverTempSpace = await receiverMetaspace.createNewLocalSpace({
+                opts: {
+                    allowCancel: false,
+                    spaceName: tempSpaceName,
+                    getFnPrompt: receiverMetaspace.getFnPrompt!,
+                    logalot
+                }
+            });
+            if (this.opts.receiverTempSpace) {
+                await this.opts.receiverTempSpace.initialized;
+            }
+        }
+        return this.opts.receiverTempSpace!; // Non-null assertion since we just created it
+    }
+
     protected async getLocalIbGib(addr: string): Promise<IbGib_V1 | undefined> {
         const res = await getFromSpace({ space: this.opts.senderSpace, addr });
         return res.ibGibs?.[0];
@@ -69,6 +91,27 @@ export class SyncPeerInnerspace_V1 extends SyncPeer_V1 {
             const sagaFrame = resFrame.ibGibs?.[0] as any;
             if (!sagaFrame) { throw new Error(`${lc} sagaFrame not found in receiver space: ${sagaFrameAddr} (E: 2c0190bd04ea408c909618193850029b)`); }
 
+            // Ensure receiverTempSpace exists
+            const receiverTempSpace = await this.ensureReceiverTempSpace();
+
+            // Store saga frame in tempSpace for easy queries during transaction
+            // (Control ibgibs like saga frames and msg stones go in BOTH spaces:
+            //  destSpace for audit trail, tempSpace for easy queries)
+            await putInSpace({ space: receiverTempSpace, ibGib: sagaFrame });
+            await receiverMetaspace.registerNewIbGib({ ibGib: sagaFrame });
+
+            // Also store the message stone (if present) in tempSpace
+            const msgStoneAddrs = sagaFrame.rel8ns?.[SYNC_MSG_REL8N_NAME];
+            if (msgStoneAddrs && msgStoneAddrs.length > 0) {
+                const resMsgStone = await getFromSpace({ space: receiverSpace, addrs: msgStoneAddrs });
+                if (resMsgStone.ibGibs) {
+                    for (const msgStone of resMsgStone.ibGibs) {
+                        await putInSpace({ space: receiverTempSpace, ibGib: msgStone });
+                        await receiverMetaspace.registerNewIbGib({ ibGib: msgStone });
+                    }
+                }
+            }
+
             // 2. Execute Receiver Logic
             // The Peer "Network" triggers the Receiver Coordinator.
             if (logalot) { console.log(`${lc} Invoking Receiver Coordinator...`); }
@@ -78,7 +121,8 @@ export class SyncPeerInnerspace_V1 extends SyncPeer_V1 {
             const result = await receiverCoordinator.handleSagaFrame({
                 sagaIbGib: sagaFrame,
                 srcGraph: {},
-                space: receiverSpace,
+                destSpace: receiverSpace,       // Query existing data
+                tempSpace: receiverTempSpace,   // Transaction space
                 metaspace: receiverMetaspace,
             });
 
@@ -91,10 +135,31 @@ export class SyncPeerInnerspace_V1 extends SyncPeer_V1 {
 
             if (logalot) { console.log(`${lc} responseFrame addr: ${getIbGibAddr({ ibGib: responseFrame })}`); }
 
-            // 3. Persist Response Data to Receiver Space (Output Buffer)
-            // The Receiver created new data (Frame, Payload). It must be saved in Receiver Space
-            // so the "Network" can PULL it back to Sender.
-            const ibGibsToPersist = [responseFrame, ...(payloadIbGibs || [])];
+            // 3. Persist Response Control IbGibs (Frame + Msg Stones) to BOTH Spaces
+            // Control ibgibs (saga frames, msg stones, identity) go in BOTH spaces:
+            // - receiverSpace (destSpace): Audit trail
+            // - receiverTempSpace: Already there from creation in tempSpace
+
+            // Ensure response frame is in receiverSpace for audit trail
+            await putInSpace({ space: receiverSpace, ibGib: responseFrame });
+            await receiverMetaspace.registerNewIbGib({ ibGib: responseFrame });
+
+            // Ensure response msg stone is in receiverSpace for audit trail
+            const responseMsgStoneAddrs = responseFrame.rel8ns?.[SYNC_MSG_REL8N_NAME];
+            if (responseMsgStoneAddrs && responseMsgStoneAddrs.length > 0) {
+                const resResponseMsgStone = await getFromSpace({ space: receiverTempSpace, addrs: responseMsgStoneAddrs });
+                if (resResponseMsgStone.ibGibs) {
+                    for (const msgStone of resResponseMsgStone.ibGibs) {
+                        await putInSpace({ space: receiverSpace, ibGib: msgStone });
+                        await receiverMetaspace.registerNewIbGib({ ibGib: msgStone });
+                    }
+                }
+            }
+
+            // 4. Persist Domain Payload IbGibs
+            // Domain ibgibs stay in tempSpace ONLY until commit
+            // (they're already in the appropriate space from coordinator's work)
+            const ibGibsToPersist = [...(payloadIbGibs || [])];
 
             // Note: payloadIbGibs might have deep dependencies. 
             // Since they were generated/fetched by the Receiver Coordinator, 
@@ -107,6 +172,14 @@ export class SyncPeerInnerspace_V1 extends SyncPeer_V1 {
 
             await putInSpace({ space: receiverSpace, ibGibs: ibGibsToPersist });
 
+            // CRITICAL: Also put payloadIbGibs into sender's tempSpace
+            // Sender needs these for merge logic in handleDeltaFrame (tempSpace queries)
+            // Do NOT put in sender's durable space - these are transactional!
+            if (this.opts.senderTempSpace && ibGibsToPersist.length > 0) {
+                console.log(`${lc} [CONFLICT DEBUG] Transferring ${ibGibsToPersist.length} payload ibgibs to sender's tempSpace`);
+                await putInSpace({ space: this.opts.senderTempSpace, ibGibs: ibGibsToPersist });
+            }
+
             // 4. Create Response Context
             const responsePayloadAddrs = payloadIbGibs?.map(p => getIbGibAddr({ ibGib: p }));
             const responseCtx = await createSyncSagaContext({