@ibgib/core-gib 0.1.18 → 0.1.19

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

@@ -0,0 +1,150 @@
+/**
+ * @module sync-innerspace-partial-update.respec
+ *
+ * Verifies Sync Scenarios where the Destination has partial history.
+ */
+
+import {
+    respecfully, lastOfAll, ifWe, iReckon,
+    ifWeMight
+} from '@ibgib/helper-gib/dist/respec-gib/respec-gib.mjs';
+const maam = `[${import.meta.url}]`, sir = maam;
+import { delay, extractErrorMsg, pretty } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+import { getIbGibAddr } from '@ibgib/ts-gib/dist/helper.mjs';
+import { getDependencyGraph } from '../common/other/graph-helper.mjs';
+
+import { SyncSagaCoordinator } from './sync-saga-coordinator.mjs';
+import { putInSpace, getFromSpace } from '../witness/space/space-helper.mjs';
+import { Metaspace_Innerspace } from '../witness/space/metaspace/metaspace-innerspace/metaspace-innerspace.mjs';
+import { InnerSpace_V1 } from '../witness/space/inner-space/inner-space-v1.mjs';
+import { createTimelineRootHelper, getTestKeystoneServiceHelper } from '../agent-helpers.mjs';
+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';
+
+const logalot = true;
+const lc = `[sync-innerspace-partial-update.respec]`;
+
+await respecfully(sir, `Sync InnerSpaces (Partial Update)`, async () => {
+
+    let metaspace: Metaspace_Innerspace;
+    let sourceSpace: InnerSpace_V1;
+    let destSpace: InnerSpace_V1;
+
+    interface TestData {
+        type: string;
+        label?: string;
+        uuid?: string;
+        n?: number;
+    }
+
+    await respecfully(sir, `Sender Newer (Partial History)`, async () => {
+        // 1. Setup Spaces
+        metaspace = new Metaspace_Innerspace(undefined);
+        await metaspace.initialize({
+            getFnAlert: () => async ({ title, msg }) => { },
+            getFnPrompt: () => async ({ title, msg }) => { return ''; },
+            getFnPromptPassword: () => async (title, msg) => { return null; },
+        });
+        while (!metaspace.initialized) { await delay(10); }
+
+        const defaultLocalUserSpace = await metaspace.getLocalUserSpace({ lock: false });
+        await defaultLocalUserSpace!.initialized;
+
+        sourceSpace = new InnerSpace_V1({
+            ...DEFAULT_INNER_SPACE_DATA_V1,
+            name: 'source',
+            uuid: 'source_uuid',
+            description: 'source test space',
+        });
+        await sourceSpace.initialized;
+
+        destSpace = new InnerSpace_V1({
+            ...DEFAULT_INNER_SPACE_DATA_V1,
+            name: 'dest',
+            uuid: 'dest_uuid',
+            description: 'dest test space',
+        });
+        await destSpace.initialized;
+
+        // 2. See Data
+        // Root -> V1 (Shared) -> V2 (Source Only)
+
+        const root = await createTimelineRootHelper<TestData>({
+            ib: 'timeline_root_partial',
+            data: { type: 'root', label: 'Root' },
+            space: sourceSpace,
+        });
+
+        // V1
+        const v1 = await mut8Timeline<TestData>({
+            timeline: root,
+            mut8Opts: { dataToAddOrPatch: { type: 'comment', label: 'V1' } },
+            metaspace,
+            space: sourceSpace,
+        });
+
+        // V2 (Source Only)
+        const v2 = await mut8Timeline<TestData>({
+            timeline: v1,
+            mut8Opts: { dataToAddOrPatch: { type: 'comment', label: 'V2' } },
+            metaspace,
+            space: sourceSpace,
+        });
+        const addrV2 = getIbGibAddr({ ibGib: v2 });
+
+        // Transfer Root & V1 to Dest (Simulate previous sync)
+        await putInSpace({ space: destSpace, ibGibs: [root, v1] });
+
+        await ifWe(sir, 'verify setup', async () => {
+            // Verify Dest has V1
+            const checkV1 = await getFromSpace({ space: destSpace, addr: getIbGibAddr({ ibGib: v1 }) });
+            iReckon(sir, checkV1.success).asTo('Dest has V1').isGonnaBeTrue();
+
+            // Verify Dest does NOT have V2
+            const checkV2 = await getFromSpace({ space: destSpace, addr: addrV2 });
+            iReckon(sir, checkV2.success && !!checkV2.ibGibs?.length).asTo('Dest has V2').isGonnaBeFalse();
+        });
+
+        // 3. Setup Sync
+        const mockKeystone = await getTestKeystoneServiceHelper();
+        const senderCoordinator = new SyncSagaCoordinator(mockKeystone);
+        const receiverCoordinator = new SyncSagaCoordinator(mockKeystone);
+
+        const peer = new SyncPeerInnerspace_V1({
+            senderSpace: sourceSpace,
+            receiverSpace: destSpace,
+            receiverCoordinator: receiverCoordinator,
+            receiverMetaspace: metaspace,
+        });
+
+        // 4. Run Sync (Source Pushes V2)
+        console.log(`${lc} Running Sync...`);
+        const resSync = await senderCoordinator.sync({
+            peer: peer,
+            localSpace: sourceSpace,
+            metaspace: metaspace,
+            domainIbGibs: [v2],
+            useSessionIdentity: false,
+        });
+
+        await resSync.done;
+
+        // 5. Verify Dest (Should now have V2)
+        console.log(`${lc} Verifying Destination...`);
+
+        await ifWe(sir, `verify dest updated`, async () => {
+            // Verify Tip (V2)
+            const getV2 = await getFromSpace({ space: destSpace, addr: addrV2 });
+            iReckon(sir, getV2.success).asTo('V2 present in Dest').isGonnaBeTrue();
+
+            // Verify V2 points to V1
+            const v2IbGib = getV2.ibGibs![0];
+            const pastAddr = v2IbGib.rel8ns?.past?.at(-1);
+            iReckon(sir, pastAddr === getIbGibAddr({ ibGib: v1 })).asTo('V2 points to V1').isGonnaBeTrue();
+        });
+
+    });
+
+});

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

@@ -33,7 +33,7 @@ await respecfully(sir, `Sync InnerSpaces`, async () => {
     let sourceSpace: InnerSpace_V1;
     let destSpace: InnerSpace_V1;
 
-    await ifWeMight(sir, `Basic Push Sync (Source -> Dest)`, async () => {
+    await ifWe(sir, `Basic Push Sync (Source -> Dest)`, async () => {
         // 1. Setup Spaces
         metaspace = new Metaspace_Innerspace(undefined);
         await metaspace.initialize({
@@ -150,18 +150,18 @@ await respecfully(sir, `Sync InnerSpaces`, async () => {
         try {
             const getChildInDest = await getFromSpace({ space: destSpace, addr: childAddr });
 
-            await ifWeMight(sir, `verify success getChildInDest`, async () => {
+            await ifWe(sir, `verify success getChildInDest`, async () => {
                 iReckon(sir, getChildInDest.success).asTo('Child present in Dest').isGonnaBeTrue();
             });
 
-            await ifWeMight(sir, `verify getChildInDest.ibGibs`, async () => {
+            await ifWe(sir, `verify getChildInDest.ibGibs`, async () => {
                 const firstChild = getChildInDest.ibGibs?.[0];
                 console.log(`${lc} firstChild: ${pretty(firstChild)}`);
                 iReckon(sir, firstChild?.data?.n).asTo('Child content matches').isGonnaBe(2);
             });
 
         } catch (error) {
-            await ifWeMight(sir, `doh`, async () => {
+            await ifWe(sir, `doh`, async () => {
                 // hack here I'm getting tired...
                 iReckon(sir, true).asTo(`error: ${extractErrorMsg(error)}`).isGonnaBeFalse();
             });

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

@@ -381,7 +381,7 @@ export class SyncSagaCoordinator {
             const result = await this.handleSagaFrame({
                 sagaIbGib: remoteFrame as SyncIbGib_V1,
                 srcGraph,
-                space: tempSpace,
+                space: localSpace, // Must be localSpace (Source) to find domain data
                 identity: sessionIdentity,
                 metaspace
             });
@@ -610,14 +610,35 @@ export class SyncSagaCoordinator {
         if (logalot) { console.log(`${lc} starting...`); }
 
         // Extract Init Data
-        const initData = messageData as SyncInitData; // Using renamed variable for clarity
+        const initData = messageData as SyncSagaMessageInitData_V1; // Using renamed variable for clarity
         if (logalot) { console.log(`${lc} initData: ${pretty(initData)} (I: 46b0f8441b96ad7a388f1ce3239dd826)`); }
         if (!initData || !initData.knowledgeVector) {
             throw new Error(`${lc} Invalid init frame: missing knowledgeVector (E: ed02c869e028d2d06841b9c7f80f2826)`);
         }
 
-        // Stones Analysis
-        // TODO: Handle stones separately if needed, though they are usually dependencies of timelines.
+        // 2. Gap Analysis
+        const conflicts: { tjp: string, localAddr?: string, remoteAddr: string, reason: string }[] = [];
+        const conflictStrategy: SyncConflictStrategy = initData.conflictStrategy || 'abort'; // Default to abort if not specified, or we should parameterize this
+
+        const deltaReqAddrs: string[] = [];
+        const pushOfferAddrs: string[] = [];
+
+        // Stones Analysis (Constants / Non-TJPs)
+        const stones = initData.stones || [];
+        if (stones.length > 0) {
+            if (logalot) { console.log(`${lc} processing stones: ${stones.length}`); }
+            // Check if we have these stones
+            const resStones = await getFromSpace({ space, addrs: stones });
+            const addrsNotFound = resStones.rawResultIbGib?.data?.addrsNotFound;
+            if (addrsNotFound && addrsNotFound.length > 0) {
+                if (logalot) { console.log(`${lc} stones missing (requesting): ${addrsNotFound.length}`); }
+                addrsNotFound.forEach(addr => {
+                    if (!deltaReqAddrs.includes(addr)) {
+                        deltaReqAddrs.push(addr);
+                    }
+                });
+            }
+        }
 
         const remoteKV = initData.knowledgeVector;
         if (logalot) { console.log(`${lc} remoteKV: ${pretty(remoteKV)} (I: 9f957862356dfeae183c200854e86e26)`); }
@@ -639,11 +660,7 @@ export class SyncSagaCoordinator {
         }
 
         // 2. Gap Analysis
-        const conflicts: { tjp: string, localAddr?: string, remoteAddr: string, reason: string }[] = [];
-        const conflictStrategy: SyncConflictStrategy = initData.conflictStrategy || 'abort'; // Default to abort if not specified, or we should parameterize this
 
-        const deltaReqAddrs: string[] = [];
-        const pushOfferAddrs: string[] = [];
 
         for (const tjp of remoteTjps) {
             const remoteAddr = remoteKV[tjp];
@@ -738,6 +755,96 @@ export class SyncSagaCoordinator {
             return { frame: conflictFrame };
         }
 
+        // 2. Add Push Offers (Missing in Local)
+        // Check if we have them. If not, ask for them.
+        for (const addr of pushOfferAddrs) {
+            const hasIt = await getFromSpace({ addr, space });
+            if (!hasIt.success || !hasIt.ibGibs || hasIt.ibGibs.length === 0) {
+                // If we don't have it, we put it in `deltaReqAddrs` of the Ack.
+                deltaReqAddrs.push(addr);
+            }
+        }
+
+        // 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.
+
+        const knowledgeVector: { [groupKey: string]: string[] } = {};
+        const relevantAddrs = new Set([...pushOfferAddrs, ...deltaReqAddrs]);
+
+        // [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 });
+                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];
+                    }
+                }
+            }
+        }
+
+        // [Smart Diff] Also check individual requested addresses (Fall back for constants/unknown TJPs)
+        for (const addr of relevantAddrs) {
+            // Only process if not already covered by TJP logic above
+            // We can't really know if it's covered easily without resolving. 
+            // But if we don't have it (requesting), we won't find it here anyway.
+            // If we DO have it (push offer), we might find it.
+            const res = await getFromSpace({ addr, space });
+            if (res.success && res.ibGibs?.[0]) {
+                const ibGib = res.ibGibs[0];
+                const tjpAddr = ibGib.rel8ns?.tjp?.[0] || getIbGibAddr({ ibGib });
+
+                if (!knowledgeVector[tjpAddr]) {
+                    const past = ibGib.rel8ns?.past || [];
+                    knowledgeVector[tjpAddr] = [getIbGibAddr({ ibGib }), ...past];
+                }
+            } else {
+                // We don't have `addr`.
+            }
+        }
+
+        // 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/Past info in `Init`? Or `pushOfferAddrs` should be richer?
+        // OR: Receiver does a check.
+        // Wait, if Sender sends V2, it's just an address.
+        // If Receiver doesn't have it, it's opaque.
+
+        // REVISIT "Constant / No TJP" logic:
+        // IF we are testing "Sender Newer", meaning Sender has V2, Receiver has V1.
+        // Sender calls `sync([V2])`. Init Frame contains `stones: [V2_Address]`.
+        // Receiver checks V2_Address. Not found.
+        // Receiver requests V2.
+        // Receiver sends Ack(DeltaReq: [V2], Knowledge: {}).
+        // Sender receives Ack. Sender sends V2 *AND* its deps (V1, Root).
+        // Receiver has V1. Sender sends V1 anyway.
+        // This is "Naive Deep Sync".
+
+        // TO ACHIEVE "Smart Diff":
+        // Receiver needs to know "Oh, V2 is a timeline tip of TJP_A".
+        // If Sender doesn't send TJP info, Receiver is blind.
+
+        // Proposed Fix (Short Term):
+        // `SyncInitData` should 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
         const sagaId = sagaIbGib.data!.uuid;
         // Create Payload Stone
@@ -746,6 +853,7 @@ export class SyncSagaCoordinator {
             stage: SyncStage.ack,
             deltaReqAddrs,
             pushOfferAddrs,
+            knowledgeVector,
         };
 
         const ackStone = await this.createSyncMsgStone({
@@ -820,7 +928,17 @@ export class SyncSagaCoordinator {
         }
 
         // 2. Process Delta Requests (Push Payload)
+        // [NEW] Smart Diff: Use knowledgeVector to skip dependencies
+        const skipAddrs = new Set<string>();
+        if (ackData.knowledgeVector) {
+            Object.values(ackData.knowledgeVector).forEach(addrs => {
+                addrs.forEach(a => skipAddrs.add(a));
+            });
+        }
+
         const payloadIbGibs: IbGib_V1[] = [];
+        // Gather all tips to sync first
+        const tipsToSync: IbGib_V1[] = [];
         for (const addr of deltaReqAddrs) {
             let ibGib = srcGraph[addr];
             if (!ibGib) {
@@ -830,12 +948,58 @@ export class SyncSagaCoordinator {
                 }
             }
             if (ibGib) {
-                payloadIbGibs.push(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? 
+        // Or `graph-helper` could support `ibGibs: []`. It currently takes `ibGib`.
+        // We will loop.
+
+        const allDepsSet = new Set<string>();
+
+        for (const tip of tipsToSync) {
+            // Always include the tip itself
+            const tipAddr = getIbGibAddr({ ibGib: tip });
+            // Only process if not skipped (though deltaReq implies they barely just asked for it)
+            // But detailed deps might be skipped.
+
+            // Get Graph with Skips
+            // Logic: "Give me everything related to Tip, EXCEPT X, Y, Z"
+            const deps = await getDependencyGraph({
+                ibGib: tip,
+                space,
+                skipAddrs: Array.from(skipAddrs)
+            });
+
+            // [FIX] Ensure Tip is included if not in deps (e.g. constant with no rel8ns)
+            let tipIncluded = false;
+
+            if (deps) {
+                Object.values(deps).forEach(d => {
+                    const dAddr = getIbGibAddr({ ibGib: d });
+                    if (!allDepsSet.has(dAddr)) {
+                        allDepsSet.add(dAddr);
+                        payloadIbGibs.push(d);
+                    }
+                    if (dAddr === tipAddr) { tipIncluded = true; }
+                });
+            }
+
+            if (!tipIncluded && !skipAddrs.has(tipAddr)) {
+                if (logalot) { console.log(`${lc} Tip not in deps, adding explicitly: ${tipAddr}`); }
+                if (!allDepsSet.has(tipAddr)) {
+                    allDepsSet.add(tipAddr);
+                    payloadIbGibs.push(tip);
+                }
+            }
+        }
+
         // 3. Create Delta Frame
         const sagaId = ackData.sagaId;
         const deltaData: SyncSagaMessageDeltaData_V1 = {

package/src/sync/sync-saga-message/sync-saga-message-types.mts

@@ -42,6 +42,11 @@ export interface SyncSagaMessageAckData_V1 extends SyncSagaMessageData_V1 {
     stage: typeof SyncStage.ack;
     deltaReqAddrs: string[];
     pushOfferAddrs: string[];
+    /**
+     * Map of group keys (TJP or Constant Addr) to list of known addresses (Full History).
+     * Used by Sender to calculate differential payloads.
+     */
+    knowledgeVector?: { [groupKey: string]: string[] };
 }
 
 export interface SyncSagaMessageDeltaData_V1 extends SyncSagaMessageData_V1, SyncDeltaData {