@ibgib/space-gib 0.0.1 → 0.0.3

package/src/client/dev-tools.mts

@@ -10,21 +10,27 @@
  * working end-to-end.
  */
 
-import { extractErrorMsg, getTimestamp, getUUID, HashAlgorithm } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+import { extractErrorMsg, getTimestamp, getUUID, } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
 import { Factory_V1 as factory } from '@ibgib/ts-gib/dist/V1/factory.mjs';
 import { ROOT } from '@ibgib/ts-gib/dist/V1/constants.mjs';
 import { getIbGibAddr, } from '@ibgib/ts-gib/dist/helper.mjs';
 import { IbGib_V1 } from '@ibgib/ts-gib/dist/V1/types.mjs';
 import { KeystoneService_V1 } from '@ibgib/core-gib/dist/keystone/keystone-service-v1.mjs';
-import { KeystoneChallengeType, KeystoneIbGib_V1, KeystoneReplenishStrategy } from '@ibgib/core-gib/dist/keystone/keystone-types.mjs';
+import { KeystoneIbGib_V1, KeystoneReplenishStrategy } from '@ibgib/core-gib/dist/keystone/keystone-types.mjs';
 import { createManagePoolConfig } from '@ibgib/core-gib/dist/keystone/keystone-config-builder.mjs';
+import { KeystoneStrategyFactory } from '@ibgib/core-gib/dist/keystone/strategy/keystone-strategy-factory.mjs';
+import { SyncPeerWebSocketSender_V1 } from '@ibgib/core-gib/dist/sync/sync-peer/sync-peer-websocket/sync-peer-websocket-sender/sync-peer-websocket-sender-v1.mjs';
+import { SyncSagaCoordinator } from '@ibgib/core-gib/dist/sync/sync-saga-coordinator.mjs';
+import { KEYSTONE_VERB_CONNECT, POOL_ID_CONNECT, POOL_ID_SYNC } from '@ibgib/core-gib/dist/keystone/keystone-constants.mjs';
 import { getGlobalMetaspace_waitIfNeeded } from "@ibgib/web-gib/dist/helpers.mjs";
+import { graphsAreEquivalent } from '@ibgib/core-gib/dist/common/other/graph-helper.mjs';
 
 import { GLOBAL_LOG_A_LOT } from './constants.mjs';
-import { SESSION_KEYSTONE_POLICY, getHandshakeChallenge } from "../common/keystone-policies.mjs";
-import { KeystoneStrategyFactory } from '@ibgib/core-gib/dist/keystone/strategy/keystone-strategy-factory.mjs';
+import {
+    SESSION_KEYSTONE_POLICY, getConnectChallenge, getSpaceGibPoolConfig
+} from "../common/keystone-policies.mjs";
 import { SpaceGibApiBridge } from './api/space-gib-api-bridge.mjs';
-import { KeystoneVerb } from '@ibgib/core-gib/dist/keystone/keystone-constants.mjs';
+import { SyncConflictStrategy } from '@ibgib/core-gib/dist/sync/sync-constants.mjs';
 
 const logalot = GLOBAL_LOG_A_LOT
 const lc = '[dev-tools]';
@@ -35,6 +41,8 @@ interface DebugState {
     targetX?: IbGib_V1;
     sessionS?: KeystoneIbGib_V1;
     sessionSecret?: string;
+    senderPeer?: SyncPeerWebSocketSender_V1;
+    sagaId?: string;
 }
 
 export const debugState: DebugState = {};
@@ -114,7 +122,7 @@ function initWsTestButton(): void {
 
 function initPrintStateButton(): void {
     const btn = document.getElementById('btn-print-dev-state') as HTMLButtonElement | null;
-    if (!btn) return;
+    if (!btn) { return; }
     btn.addEventListener('click', () => {
         devLog(`Printing debug state to console...`);
         console.dir(debugState);
@@ -128,7 +136,7 @@ function initPrintStateButton(): void {
 function initCreateDomainKeystoneButton(): void {
     const lc_fn = `${lc}[initCreateDomainKeystoneButton]`;
     const btn = document.getElementById('btn-create-domain-keystone') as HTMLButtonElement | null;
-    if (!btn) return;
+    if (!btn) { return; }
 
     btn.addEventListener('click', async () => {
         try {
@@ -177,7 +185,7 @@ function initCreateDomainKeystoneButton(): void {
 
             // Enable next step
             const nextBtn = document.getElementById('btn-create-test-ibgib') as HTMLButtonElement;
-            if (nextBtn) nextBtn.disabled = false;
+            if (nextBtn) { nextBtn.disabled = false; }
 
         } catch (error) {
             devLog(`✗ ${extractErrorMsg(error)}`);
@@ -219,7 +227,7 @@ function initCreateTestIbGibButton(): void {
 
             // Enable next step
             const nextBtn = document.getElementById('btn-create-session-keystone') as HTMLButtonElement;
-            if (nextBtn) nextBtn.disabled = false;
+            if (nextBtn) { nextBtn.disabled = false; }
         } catch (error) {
             devLog(`✗ ${extractErrorMsg(error)}`);
             console.error(`${lc_fn} ${extractErrorMsg(error)}`);
@@ -276,19 +284,19 @@ function initCreateSessionKeystoneButton(): void {
                         allowedVerbs: [],
                     },
                     {
-                        id: SESSION_KEYSTONE_POLICY.HANDSHAKE_POOL.ID,
+                        id: SESSION_KEYSTONE_POLICY.CONNECT_POOL.ID,
                         salt: await getUUID(),
                         type: SESSION_KEYSTONE_POLICY.COMMON.TYPE,
                         algo: SESSION_KEYSTONE_POLICY.COMMON.ALGO,
                         rounds: SESSION_KEYSTONE_POLICY.COMMON.ROUNDS,
                         behavior: {
-                            size: SESSION_KEYSTONE_POLICY.HANDSHAKE_POOL.SIZE,
+                            size: SESSION_KEYSTONE_POLICY.CONNECT_POOL.SIZE,
                             replenish: SESSION_KEYSTONE_POLICY.COMMON.REPLENISH,
-                            selectSequentially: SESSION_KEYSTONE_POLICY.HANDSHAKE_POOL.SELECT_SEQUENTIALLY,
-                            selectRandomly: SESSION_KEYSTONE_POLICY.HANDSHAKE_POOL.SELECT_RANDOMLY,
-                            targetBindingChars: SESSION_KEYSTONE_POLICY.HANDSHAKE_POOL.TARGET_BINDING_CHARS,
+                            selectSequentially: SESSION_KEYSTONE_POLICY.CONNECT_POOL.SELECT_SEQUENTIALLY,
+                            selectRandomly: SESSION_KEYSTONE_POLICY.CONNECT_POOL.SELECT_RANDOMLY,
+                            targetBindingChars: SESSION_KEYSTONE_POLICY.CONNECT_POOL.TARGET_BINDING_CHARS,
                         },
-                        allowedVerbs: [SESSION_KEYSTONE_POLICY.HANDSHAKE_POOL.VERB],
+                        allowedVerbs: [SESSION_KEYSTONE_POLICY.CONNECT_POOL.VERB],
                     }
                 ],
                 metaspace,
@@ -309,7 +317,7 @@ function initCreateSessionKeystoneButton(): void {
 
             // Enable next step
             const nextBtn = document.getElementById('btn-evolve-domain-keystone') as HTMLButtonElement;
-            if (nextBtn) nextBtn.disabled = false;
+            if (nextBtn) { nextBtn.disabled = false; }
         } catch (error) {
             devLog(`✗ ${extractErrorMsg(error)}`);
             console.error(`${lc_fn} ${extractErrorMsg(error)}`);
@@ -383,7 +391,7 @@ function initEvolveDomainKeystoneButton(): void {
 
             // Enable next step
             const nextBtn = document.getElementById('btn-perform-sync') as HTMLButtonElement;
-            if (nextBtn) nextBtn.disabled = false;
+            if (nextBtn) { nextBtn.disabled = false; }
 
         } catch (error) {
             devLog(`✗ ${extractErrorMsg(error)}`);
@@ -394,19 +402,19 @@ function initEvolveDomainKeystoneButton(): void {
 }
 
 // ---------------------------------------------------------------------------
-// Perform Sync Handshake (S) button
+// Perform Sync Connect (S) button
 // ---------------------------------------------------------------------------
 
 function initPerformSyncButton(): void {
     const lc_fn = `${lc}[initPerformSyncButton]`;
     const btn = document.getElementById('btn-perform-sync') as HTMLButtonElement | null;
-    if (!btn) return;
+    if (!btn) { return; }
 
     btn.addEventListener('click', async () => {
         try {
             debugger; // walk through sync
             btn.disabled = true;
-            devLog('Initiating Sync Handshake via WebSocket...');
+            devLog('Initiating Sync Connect via WebSocket...');
 
             const sessionS = debugState.sessionS;
             const sessionSecret = debugState.sessionSecret;
@@ -423,17 +431,17 @@ function initPerformSyncButton(): void {
             if (!space) { throw new Error("No space."); }
 
             devLog('Pre-solving upfront picket-fence challenge...');
-            const handshakePool = (sessionS.data?.challengePools ?? []).find(p => p.id === SESSION_KEYSTONE_POLICY.HANDSHAKE_POOL.ID);
-            if (!handshakePool) {
-                throw new Error(`Session keystone missing "${SESSION_KEYSTONE_POLICY.HANDSHAKE_POOL.ID}" pool`);
+            const connectPool = (sessionS.data?.challengePools ?? []).find(p => p.id === SESSION_KEYSTONE_POLICY.CONNECT_POOL.ID);
+            if (!connectPool) {
+                throw new Error(`Session keystone missing "${SESSION_KEYSTONE_POLICY.CONNECT_POOL.ID}" pool`);
             }
 
-            const { challengeId } = getHandshakeChallenge(sessionS);
-            const strategy = KeystoneStrategyFactory.create({ config: handshakePool.config });
+            const { challengeId } = getConnectChallenge(sessionS);
+            const strategy = KeystoneStrategyFactory.create({ config: connectPool.config });
             const poolSecret = await strategy.derivePoolSecret({ masterSecret: sessionSecret });
             const solution = await strategy.generateSolution({
                 poolSecret,
-                poolId: SESSION_KEYSTONE_POLICY.HANDSHAKE_POOL.ID,
+                poolId: SESSION_KEYSTONE_POLICY.CONNECT_POOL.ID,
                 challengeId
             });
 
@@ -464,16 +472,16 @@ function initPerformSyncButton(): void {
                         }));
                     } else if (msg.type === 'auth-challenge') {
                         const { challengeUuid, demandedIds } = msg;
-                        devLog(`→ server demanded ${demandedIds.length} ids. Signing handshake proof...`);
+                        devLog(`→ server demanded ${demandedIds.length} ids. Signing connect proof...`);
 
                         const keystoneService = new KeystoneService_V1();
                         const proofFrame = await keystoneService.sign({
                             latestKeystone: sessionS,
                             masterSecret: sessionSecret,
-                            poolId: 'handshake',
+                            poolId: POOL_ID_CONNECT,
                             requiredChallengeIds: demandedIds,
                             claim: {
-                                verb: 'handshake',
+                                verb: KEYSTONE_VERB_CONNECT,
                                 target: challengeUuid
                             },
                             metaspace,
@@ -486,10 +494,10 @@ function initPerformSyncButton(): void {
                             proofFrame
                         }));
                     } else if (msg.type === 'auth-ok') {
-                        devLog('✓ Handshake SUCCESS! Sync session authorized.');
+                        devLog('✓ Connect SUCCESS! Sync session authorized.');
                         btn.textContent = '✓ Sync Authorized';
                     } else if (msg.type === 'auth-fail') {
-                        devLog(`✗ Handshake FAILED: ${msg.message}`);
+                        devLog(`✗ Connect FAILED: ${msg.message}`);
                         btn.disabled = false;
                     }
                 } catch (error) {
@@ -517,6 +525,675 @@ function initPerformSyncButton(): void {
     });
 }
 
+// ---------------------------------------------------------------------------
+// Phase 1B: Standardized Setup / Sync / Check testing loop
+// ---------------------------------------------------------------------------
+
+interface PhaseSetupOptions {
+    phaseText: '1B' | '2B' | '3B';
+    btnId: string;
+    nextBtnId: string;
+    masterSecret: string;
+    syncSalt: string;
+    manageSalt: string;
+    ib: string;
+    data: any;
+}
+
+async function performPhaseSetup(opts: PhaseSetupOptions): Promise<void> {
+    const lc_fn = `${lc}[performPhaseSetup(${opts.phaseText})]`;
+    const btn = document.getElementById(opts.btnId) as HTMLButtonElement | null;
+    if (!btn) { return; }
+
+    try {
+        btn.disabled = true;
+        devLog(`${opts.phaseText} Setup: Generating Alice's long-lived Domain Keystone (I) and Target (X)...`);
+
+        const metaspace = await getGlobalMetaspace_waitIfNeeded();
+        const space = await metaspace.getLocalUserSpace({});
+        if (!space) { throw new Error("No default space found in metaspace."); }
+
+        const keystoneService = new KeystoneService_V1();
+
+        // 1. Create Genesis Domain Keystone (I^Itjp) in local space
+        const domainI = await keystoneService.genesis({
+            masterSecret: opts.masterSecret,
+            configs: [
+                getSpaceGibPoolConfig('sync', opts.syncSalt),
+                getSpaceGibPoolConfig('manage', opts.manageSalt),
+            ],
+            metaspace,
+            space,
+            frameDetails: { client: 'space-gib-web-dev', timestamp: getTimestamp() }
+        });
+
+        debugState.domainI = domainI;
+        debugState.domainIMasterSecret = opts.masterSecret;
+
+        devLog(`${opts.phaseText} Setup: ✓ Domain Keystone (I) created locally: ${getIbGibAddr({ ibGib: domainI })}`);
+        devLog(`${opts.phaseText} Setup: Starting postGenesisKeystone...`);
+
+        // 2. Post Genesis Domain Keystone to receiver/server
+        const apiBridge = new SpaceGibApiBridge();
+        const resGenesis = await apiBridge.postGenesisKeystone(domainI);
+        if (resGenesis.success) {
+            devLog(`${opts.phaseText} Setup: ✓ Domain Keystone registered and stored on receiver (server).`);
+        } else {
+            devLog(`${opts.phaseText} Setup: X postGenesisKeystone failed: ${resGenesis.message}.`);
+            throw new Error(`${opts.phaseText} Setup: Server rejected genesis domain keystone: ${resGenesis.message}`);
+        }
+
+        // 3. Create Test IbGib (X) locally
+        const resX = await factory.firstGen({
+            parentIbGib: ROOT,
+            ib: opts.ib,
+            data: opts.data,
+            dna: true,
+            nCounter: true,
+            tjp: { uuid: true, timestamp: true }
+        });
+        const xIbGib = resX.newIbGib;
+
+        // Persist target X to local space so coordinator can build the sync history
+        await metaspace.persistTransformResult({ resTransform: resX, space });
+        await metaspace.registerNewIbGib({ ibGib: xIbGib });
+
+        debugState.targetX = xIbGib;
+        devLog(`${opts.phaseText} Setup: ✓ Target (X) created and persisted locally: ${getIbGibAddr({ ibGib: xIbGib })}`);
+
+        devLog(`✓ ${opts.phaseText} Setup Complete! Ready for ${opts.phaseText} Sync.`);
+        btn.textContent = `✓ ${opts.phaseText} Setup Complete`;
+
+        // Enable next button in the phase flow
+        const syncBtn = document.getElementById(opts.nextBtnId) as HTMLButtonElement | null;
+        if (syncBtn) { syncBtn.disabled = false; }
+
+    } catch (error) {
+        devLog(`✗ ${opts.phaseText} Setup FAILED: ${extractErrorMsg(error)}`);
+        console.error(`${lc_fn} ${opts.phaseText} Setup error:`, error);
+        btn.disabled = false;
+    }
+}
+
+interface PhaseSyncOptions {
+    phaseText: '1B' | '2B' | '3B';
+    btnId: string;
+    nextBtnId: string;
+    expectSyncFailure?: boolean;
+    failureMessageSuffix?: string;
+}
+
+async function performPhaseSync(opts: PhaseSyncOptions): Promise<void> {
+    const lc_fn = `${lc}[performPhaseSync(${opts.phaseText})]`;
+    const btn = document.getElementById(opts.btnId) as HTMLButtonElement | null;
+    if (!btn) { return; }
+
+    try {
+        btn.disabled = true;
+        devLog(`${opts.phaseText} Sync: Executing senderCoordinator.sync(...) using WebSocket Peer...`);
+
+        const domainI = debugState.domainI;
+        const targetX = debugState.targetX;
+        if (!domainI || !targetX) {
+            devLog(`⚠ ${opts.phaseText} Sync: Missing setup state. Please run Setup first.`);
+            btn.disabled = false;
+            return;
+        }
+
+        const domainAddr = getIbGibAddr({ ibGib: domainI });
+        const metaspace = await getGlobalMetaspace_waitIfNeeded();
+        const space = await metaspace.getLocalUserSpace({});
+        if (!space) { throw new Error("No default space."); }
+
+        const protocol = location.protocol === 'https:' ? 'wss:' : 'ws:';
+        const senderPeer = new SyncPeerWebSocketSender_V1({
+            classname: 'SyncPeerWebSocketSender_V1',
+            httpEvolveUrl: `${location.protocol}//${location.host}/api/keystone/evolve/${encodeURIComponent(domainAddr)}`,
+            wsUrl: `${protocol}//${location.host}/api/sync/ws/${encodeURIComponent(domainAddr)}`
+        });
+
+        const coordinator = new SyncSagaCoordinator();
+        const sagaId = await getUUID();
+        debugState.sagaId = sagaId;
+        debugState.senderPeer = senderPeer;
+
+        await senderPeer.initializeOpts({
+            localMetaspace: metaspace,
+            localSpace: space,
+            senderIdentity: domainI,
+            fnSenderSecret: async () => debugState.domainIMasterSecret!,
+            sagaId,
+            sessionConnectPoolConfig: SESSION_KEYSTONE_POLICY.CONNECT_POOL as any,
+            sessionSyncPoolConfig: SESSION_KEYSTONE_POLICY.DEFAULT_POOL as any,
+            targetAddrs: [domainAddr]
+        });
+
+        try {
+            const syncSaga = await coordinator.sync({
+                domainIbGibs: [targetX],
+                senderIdentity: domainI,
+                fnSenderSecret: async () => debugState.domainIMasterSecret!,
+                peer: senderPeer,
+                localSpace: space,
+                metaspace,
+                conflictStrategy: SyncConflictStrategy.optimisticWithLCS,
+            });
+            await syncSaga.done;
+        } catch (err) {
+            if (opts.expectSyncFailure) {
+                devLog(`${opts.phaseText} Sync: Coordinator sync executed (${opts.failureMessageSuffix ?? 'errors expected'}): ${extractErrorMsg(err)}`);
+            } else {
+                throw err;
+            }
+        }
+
+        devLog(`✓ ${opts.phaseText} Sync Execution Complete! Ready for State Checks.`);
+        btn.textContent = `✓ ${opts.phaseText} Sync Run`;
+
+        const checkBtn = document.getElementById(opts.nextBtnId) as HTMLButtonElement | null;
+        if (checkBtn) { checkBtn.disabled = false; }
+
+    } catch (error) {
+        devLog(`✗ ${opts.phaseText} Sync FAILED: ${extractErrorMsg(error)}`);
+        console.error(`${lc_fn} ${opts.phaseText} Sync error:`, error);
+        btn.disabled = false;
+    }
+}
+
+function init1bSetupButton(): void {
+    const btn = document.getElementById('btn-1b-setup') as HTMLButtonElement | null;
+    if (!btn) { return; }
+    btn.addEventListener('click', () => {
+        performPhaseSetup({
+            phaseText: '1B',
+            btnId: 'btn-1b-setup',
+            nextBtnId: 'btn-1b-sync',
+            masterSecret: 'test-sender-secret-phase1',
+            syncSalt: 'senderidentitysyncsaltphase1',
+            manageSalt: 'senderidentitymanagesaltphase1',
+            ib: 'test data',
+            data: { hello: 'world', random: Math.random() }
+        });
+    });
+}
+
+function init1bSyncButton(): void {
+    const btn = document.getElementById('btn-1b-sync') as HTMLButtonElement | null;
+    if (!btn) { return; }
+    btn.addEventListener('click', () => {
+        performPhaseSync({
+            phaseText: '1B',
+            btnId: 'btn-1b-sync',
+            nextBtnId: 'btn-1b-check',
+            expectSyncFailure: true,
+            failureMessageSuffix: 'establish phase successfully run; connection/sync errors expected in 1B'
+        });
+    });
+}
+
+function init1bCheckButton(): void {
+    const lc_fn = `${lc}[init1bCheckButton]`;
+    const btn = document.getElementById('btn-1b-check') as HTMLButtonElement | null;
+    if (!btn) { return; }
+
+    btn.addEventListener('click', async () => {
+        try {
+            devLog('1B Check: Asserting cryptographic and durable state expectations from respec...');
+
+            debugger; // allow for walkthrough 1B check
+            const metaspace = await getGlobalMetaspace_waitIfNeeded();
+            const space = await metaspace.getLocalUserSpace({});
+            if (!space) { throw new Error("No default space."); }
+
+            const domainI = debugState.domainI!;
+            const targetX = debugState.targetX!;
+            const xAddr = getIbGibAddr({ ibGib: targetX });
+
+            // 1. Resolve evolved sender identity I1 locally
+            const newSenderIdentityAddr = await metaspace.getLatestAddr({
+                addr: getIbGibAddr({ ibGib: domainI }),
+                space
+            });
+
+            if (!newSenderIdentityAddr) {
+                devLog('✗ Check: Evolved domain keystone tip I1 NOT found in local space!');
+                return;
+            }
+            devLog(`✓ Check: Evolved Domain Keystone (I1) created and stored locally.`);
+
+            const getRes = await metaspace.get({ addrs: [newSenderIdentityAddr], space });
+            const newSenderIdentity = getRes.ibGibs?.[0] as KeystoneIbGib_V1 | undefined;
+
+            if (!newSenderIdentity) {
+                devLog('✗ Check: Failed to load I1 from local space.');
+                return;
+            }
+
+            const syncProof = newSenderIdentity.data?.proofs?.find(p => p.claim?.verb === 'sync');
+            if (!syncProof) {
+                devLog('✗ Check: I1 is missing sync-verb claim proof!');
+            } else {
+                devLog('✓ Check: I1 contains valid sync-verb claim proof.');
+            }
+
+            const sessionIdentityTjpAddr = syncProof?.claim?.target;
+            if (!sessionIdentityTjpAddr) {
+                devLog('✗ Check: I1 sync claim does not target a session keystone.');
+                return;
+            }
+            devLog(`✓ Check: Sync claim targets session keystone: ${sessionIdentityTjpAddr}`);
+
+            // 2. Load Session Keystone (S) locally
+            const sRes = await metaspace.get({ addrs: [sessionIdentityTjpAddr], space });
+            const sessionIdentity = sRes.ibGibs?.[0] as KeystoneIbGib_V1 | undefined;
+
+            if (!sessionIdentity) {
+                devLog('✗ Check: Session Keystone (S) NOT found in local space.');
+                return;
+            }
+            devLog('✓ Check: Session Keystone (S) successfully created locally.');
+
+            const sPools = sessionIdentity.data?.challengePools ?? [];
+            const hasConnectPool = sPools.some(p => p.id === POOL_ID_CONNECT);
+            const hasSyncPool = sPools.some(p => p.id === POOL_ID_SYNC);
+
+            if (hasConnectPool && hasSyncPool) {
+                devLog('✓ Check: S contains both connect and sync challenge pools.');
+            } else {
+                devLog(`✗ Check: S is missing challenge pools! (connect: ${hasConnectPool}, sync: ${hasSyncPool})`);
+            }
+
+            // we don't check this yet until sync ping pong
+            // const targetAddrs = sessionIdentity.data?.frameDetails?.targetAddrs ?? [];
+            // if (targetAddrs.includes(xAddr)) {
+            //     devLog('✓ Check: S is securely bound to target domain X in frameDetails.');
+            // } else {
+            //     devLog('✗ Check: S is not bound to target domain X!');
+            // }
+
+            // #region 3. Verify Server-Side (receiver) registrations via GET REST API
+            devLog('Check: Verifying registrations on server (receiver metaspace)...');
+            const apiBridge = new SpaceGibApiBridge();
+
+            // Check if I, evolved I1 and session S exist on server
+            let hasI = false;
+            let hasI1 = false;
+            let hasS = false;
+
+            const domainAddr = getIbGibAddr({ ibGib: domainI });
+            const resGetDomainIGraphFromServer = await apiBridge.getKeystoneGraph(domainAddr);
+            if (resGetDomainIGraphFromServer.success && resGetDomainIGraphFromServer.graph) {
+                const domainGraph = resGetDomainIGraphFromServer.graph;
+                hasI = domainGraph[domainAddr] !== undefined;
+                hasI1 = domainGraph[newSenderIdentityAddr] !== undefined;
+            } else {
+                devLog(`✗ Check Server: Failed to fetch keystone graph from server: ${resGetDomainIGraphFromServer.message}`);
+            }
+
+            const resGetSessionSFromServer = await apiBridge.getIbGib(domainAddr, sessionIdentityTjpAddr);
+            if (resGetSessionSFromServer.success && resGetSessionSFromServer.ibGib) {
+                hasS = true;
+            } else {
+                devLog(`✗ Check Server: Failed to fetch session keystone from server: ${resGetSessionSFromServer.message}`);
+            }
+
+            if (hasI) { devLog('✓ Check Server: Genesis Domain Keystone (I) registered on server.'); }
+            else devLog('✗ Check Server: Genesis Domain Keystone (I) missing on server!');
+            if (hasI1) { devLog('✓ Check Server: Evolved Domain Keystone (I1) accepted and stored on server.'); }
+            else devLog('✗ Check Server: Evolved Domain Keystone (I1) missing on server!');
+            if (hasS) { devLog('✓ Check Server: Session Keystone (S) accepted and stored on server.'); }
+            else devLog('✗ Check Server: Session Keystone (S) missing on server!');
+            if (hasI && hasI1 && hasS) {
+                devLog('🎉 ALL PHASE 1B ESTABLISH CHECKS PASSED FLAWLESSLY! ✓');
+                btn.textContent = '✓ 1B All Passed';
+
+                const btn2bSetup = document.getElementById('btn-2b-setup') as HTMLButtonElement | null;
+                if (btn2bSetup) { btn2bSetup.disabled = false; }
+            }
+
+            // #endregion 3. Verify Server-Side (receiver) registrations via GET REST API
+
+        } catch (error) {
+            devLog(`✗ 1B Check FAILED: ${extractErrorMsg(error)}`);
+            console.error(`${lc_fn} 1B Check error:`, error);
+        }
+    });
+}
+
+// ---------------------------------------------------------------------------
+// Phase 2B Implementation
+// ---------------------------------------------------------------------------
+
+function init2bSetupButton(): void {
+    const btn = document.getElementById('btn-2b-setup') as HTMLButtonElement | null;
+    if (!btn) { return; }
+    btn.addEventListener('click', () => {
+        performPhaseSetup({
+            phaseText: '2B',
+            btnId: 'btn-2b-setup',
+            nextBtnId: 'btn-2b-sync',
+            masterSecret: 'test-sender-secret-phase2',
+            syncSalt: 'senderidentitysyncsaltphase2',
+            manageSalt: 'senderidentitymanagesaltphase2',
+            ib: 'test data',
+            data: { hello: 'world2', random: Math.random() }
+        });
+    });
+}
+
+function init2bSyncButton(): void {
+    const btn = document.getElementById('btn-2b-sync') as HTMLButtonElement | null;
+    if (!btn) { return; }
+    btn.addEventListener('click', () => {
+        performPhaseSync({
+            phaseText: '2B',
+            btnId: 'btn-2b-sync',
+            nextBtnId: 'btn-2b-check',
+            expectSyncFailure: true,
+            failureMessageSuffix: 'connect phase successfully run; subsequent sync errors expected in 2B'
+        });
+    });
+}
+
+function init2bCheckButton(): void {
+    const lc_fn = `${lc}[init2bCheckButton]`;
+    const btn = document.getElementById('btn-2b-check') as HTMLButtonElement | null;
+    if (!btn) { return; }
+
+    btn.addEventListener('click', async () => {
+        try {
+            debugger; // allow for walkthrough 2B check
+            devLog('2B Check: Asserting cryptographic and WebSocket state expectations...');
+
+            const metaspace = await getGlobalMetaspace_waitIfNeeded();
+            const space = await metaspace.getLocalUserSpace({});
+            if (!space) { throw new Error("No default space."); }
+
+            const domainI = debugState.domainI!;
+            const targetX = debugState.targetX!;
+            const xAddr = getIbGibAddr({ ibGib: targetX });
+
+            // 1. Resolve evolved sender identity I1 locally
+            const domainAddr = getIbGibAddr({ ibGib: domainI });
+            const newSenderIdentityAddr = await metaspace.getLatestAddr({
+                addr: domainAddr,
+                space
+            });
+
+            if (!newSenderIdentityAddr) {
+                devLog('✗ Check: Evolved domain keystone tip I1 NOT found in local space!');
+                return;
+            }
+            devLog(`✓ Check: Evolved Domain Keystone (I1) created and stored locally.`);
+
+            const getRes = await metaspace.get({ addrs: [newSenderIdentityAddr], space });
+            const newSenderIdentity = getRes.ibGibs?.[0] as KeystoneIbGib_V1 | undefined;
+
+            if (!newSenderIdentity) {
+                devLog('✗ Check: Failed to load I1 from local space.');
+                return;
+            }
+
+            const syncProof = newSenderIdentity.data?.proofs?.find(p => p.claim?.verb === 'sync');
+            const sessionIdentityTjpAddr = syncProof?.claim?.target;
+            if (!sessionIdentityTjpAddr) {
+                devLog('✗ Check: I1 sync claim does not target a session keystone.');
+                return;
+            }
+            devLog(`✓ Check: Sync claim targets session keystone: ${sessionIdentityTjpAddr}`);
+
+            // 2. Load Session Keystone (S) locally and get latest tip
+            const latestSessionSAddr = await metaspace.getLatestAddr({
+                addr: sessionIdentityTjpAddr,
+                space
+            });
+            if (!latestSessionSAddr) {
+                devLog('✗ Check: Latest Session Keystone (S) NOT found in local space.');
+                return;
+            }
+            devLog(`✓ Check: Found latest session keystone (S) locally.`);
+
+            const sRes = await metaspace.get({ addrs: [latestSessionSAddr], space });
+            const sessionIdentity = sRes.ibGibs?.[0] as KeystoneIbGib_V1 | undefined;
+
+            if (!sessionIdentity) {
+                devLog('✗ Check: Failed to load latest Session Keystone (S).');
+                return;
+            }
+
+            // Verify S contains connect and sync pools
+            const sPools = sessionIdentity.data?.challengePools ?? [];
+            const connectPool = sPools.find(p => p.id === POOL_ID_CONNECT);
+            const syncPool = sPools.find(p => p.id === POOL_ID_SYNC);
+
+            if (connectPool && syncPool) {
+                devLog('✓ Check: S contains both connect and sync challenge pools.');
+            } else {
+                devLog(`✗ Check: S is missing challenge pools! (connect: ${!!connectPool}, sync: ${!!syncPool})`);
+                return;
+            }
+
+            // Verify S was successfully evolved (depleted connect pool)
+            const remainingChallenges = Object.keys(connectPool.challenges).length;
+            if (remainingChallenges === 0) {
+                devLog('✓ Check: S connect pool successfully depleted (0 challenges remaining).');
+            } else {
+                devLog(`✗ Check: S connect pool not depleted! (${remainingChallenges} challenges remaining)`);
+                return;
+            }
+
+            // we don't check this yet until sync ping pong
+            // const targetAddrs = sessionIdentity.data?.frameDetails?.targetAddrs ?? [];
+            // if (targetAddrs.includes(xAddr)) {
+            //     devLog('✓ Check: S is securely bound to target domain X in frameDetails.');
+            // } else {
+            //     devLog('✗ Check: S is not bound to target domain X!');
+            // }
+
+            // 3. Verify WebSocket Connection is open and active
+            if (debugState.senderPeer && debugState.senderPeer.isSocketOpen) {
+                devLog('✓ Check: WebSocket connection is active and OPEN.');
+            } else {
+                devLog('✗ Check: WebSocket connection is NOT open or peer is missing!');
+                return;
+            }
+
+            devLog('🎉 ALL PHASE 2B CONNECT CHECKS PASSED FLAWLESSLY! ✓');
+            btn.textContent = '✓ 2B All Passed';
+
+            // Enable Phase 3B setup
+            const p3SetupBtn = document.getElementById('btn-3b-setup') as HTMLButtonElement | null;
+            if (p3SetupBtn) { p3SetupBtn.disabled = false; }
+
+        } catch (error) {
+            devLog(`✗ 2B Check FAILED: ${extractErrorMsg(error)}`);
+            console.error(`${lc_fn} 2B Check error:`, error);
+        }
+    });
+}
+
+function init3bSetupButton(): void {
+    const btn = document.getElementById('btn-3b-setup') as HTMLButtonElement | null;
+    if (!btn) { return; }
+    btn.addEventListener('click', () => {
+        performPhaseSetup({
+            phaseText: '3B',
+            btnId: 'btn-3b-setup',
+            nextBtnId: 'btn-3b-sync',
+            masterSecret: 'test-sender-secret-phase3',
+            syncSalt: 'senderidentitysyncsaltphase3',
+            manageSalt: 'senderidentitymanagesaltphase3',
+            ib: 'test data 3b',
+            data: { hello: 'world3', random: Math.random() }
+        });
+    });
+}
+
+function init3bSyncButton(): void {
+    const btn = document.getElementById('btn-3b-sync') as HTMLButtonElement | null;
+    if (!btn) { return; }
+    btn.addEventListener('click', () => {
+        performPhaseSync({
+            phaseText: '3B',
+            btnId: 'btn-3b-sync',
+            nextBtnId: 'btn-3b-check'
+        });
+    });
+}
+
+function init3bCheckButton(): void {
+    const lc_fn = `${lc}[init3bCheckButton]`;
+    const btn = document.getElementById('btn-3b-check') as HTMLButtonElement | null;
+    if (!btn) { return; }
+
+    btn.addEventListener('click', async () => {
+        try {
+            debugger; // allow for walkthrough 3B check
+            devLog('3B Check: Asserting cryptographic and WebSocket state expectations...');
+
+            const metaspace = await getGlobalMetaspace_waitIfNeeded();
+            const space = await metaspace.getLocalUserSpace({});
+            if (!space) { throw new Error("No default space."); }
+
+            const domainI = debugState.domainI!;
+            const targetX = debugState.targetX!;
+            const xAddr = getIbGibAddr({ ibGib: targetX });
+            const domainAddr = getIbGibAddr({ ibGib: domainI });
+
+            // 1. Assert Target X exists locally (with evolved timeline) and get latest local graph
+            const latestLocalXAddr = await metaspace.getLatestAddr({
+                addr: xAddr,
+                space
+            });
+            if (!latestLocalXAddr) {
+                devLog('✗ Check: Evolved target X NOT found in local space!');
+                return;
+            }
+            devLog(`✓ Check: Evolved target X found locally at: ${latestLocalXAddr}`);
+
+            const localXGraph = await metaspace.getDependencyGraph({
+                ibGibAddr: latestLocalXAddr,
+                space
+            });
+            if (!localXGraph || Object.keys(localXGraph).length === 0) {
+                devLog('✗ Check: Failed to load target X dependency graph locally.');
+                return;
+            }
+            devLog(`✓ Check: Target X local graph loaded (${Object.keys(localXGraph).length} nodes).`);
+
+            // 2. Fetch server's Target X graph via API bridge
+            const apiBridge = new SpaceGibApiBridge();
+            const serverGetRes = await apiBridge.getIbGibGraph(domainAddr, xAddr, true);
+            if (!serverGetRes.success || !serverGetRes.graph) {
+                devLog(`✗ Check: Failed to fetch target X graph from server: ${serverGetRes.message}`);
+                return;
+            }
+            const serverXGraph = serverGetRes.graph;
+            devLog(`✓ Check: Target X server graph loaded (${Object.keys(serverXGraph).length} nodes).`);
+
+            // 3. Verify graphs are equivalent using graphsAreEquivalent
+            const equal = graphsAreEquivalent({ graphA: localXGraph, graphB: serverXGraph });
+            if (equal) {
+                devLog('✓ Check: Target X dependency graphs are equivalent on client and server.');
+            } else {
+                devLog('✗ Check: Target X dependency graphs mismatch between client and server!');
+                return;
+            }
+
+            // 4. Assert evolved sender identity I1 exists locally and on server
+            const latestLocalIAddr = await metaspace.getLatestAddr({
+                addr: domainAddr,
+                space
+            });
+            if (!latestLocalIAddr) {
+                devLog('✗ Check: Evolved domain keystone tip I1 NOT found in local space!');
+                return;
+            }
+            devLog(`✓ Check: Evolved Domain Keystone (I1) exists locally.`);
+
+            const getRes = await metaspace.get({ addrs: [latestLocalIAddr], space });
+            const localI = getRes.ibGibs?.[0] as KeystoneIbGib_V1 | undefined;
+            if (!localI) {
+                devLog('✗ Check: Failed to load I1 from local space.');
+                return;
+            }
+
+            const syncProof = localI.data?.proofs?.find(p => p.claim?.verb === 'sync');
+            const sessionIdentityTjpAddr = syncProof?.claim?.target;
+            if (!sessionIdentityTjpAddr) {
+                devLog('✗ Check: I1 sync claim does not target a session keystone.');
+                return;
+            }
+
+            const serverIGetRes = await apiBridge.getIbGib(domainAddr, latestLocalIAddr);
+            if (!serverIGetRes.success || !serverIGetRes.ibGib) {
+                devLog(`✗ Check: Evolved Domain Keystone (I1) NOT found on server!`);
+                return;
+            }
+            devLog(`✓ Check: Evolved Domain Keystone (I1) exists on server.`);
+
+            // 5. Assert session identity S tip exists locally and on server
+            const latestLocalSAddr = await metaspace.getLatestAddr({
+                addr: sessionIdentityTjpAddr,
+                space
+            });
+            if (!latestLocalSAddr) {
+                devLog('✗ Check: Latest Session Keystone (S) NOT found in local space.');
+                return;
+            }
+            devLog(`✓ Check: Found latest session keystone (S) locally: ${latestLocalSAddr}`);
+
+            const localSRes = await metaspace.get({ addrs: [latestLocalSAddr], space });
+            const sessionS = localSRes.ibGibs?.[0] as KeystoneIbGib_V1 | undefined;
+            if (!sessionS) {
+                devLog('✗ Check: Failed to load latest Session Keystone (S) locally.');
+                return;
+            }
+
+            // Verify S evolved to correct n (n === 3 or 4)
+            const n = sessionS.data?.n;
+            devLog(`✓ Check: S tip evolved to n = ${n}.`);
+            if (n !== 3 && n !== 4) {
+                devLog(`⚠ Check: Expected S to evolve to n = 3 or 4, got n = ${n}. Continuing anyway...`);
+            }
+
+            const serverSGetRes = await apiBridge.getIbGib(domainAddr, latestLocalSAddr);
+            if (!serverSGetRes.success || !serverSGetRes.ibGib) {
+                devLog(`✗ Check: Latest Session Keystone (S) NOT found on server!`);
+                return;
+            }
+            devLog(`✓ Check: Latest Session Keystone (S) exists on server.`);
+
+            // 6. Assert S graph is identical on client and server
+            const localSGraph = await metaspace.getDependencyGraph({
+                ibGibAddr: latestLocalSAddr,
+                space
+            });
+            const serverSGetGraphRes = await apiBridge.getIbGibGraph(domainAddr, sessionIdentityTjpAddr, true);
+            if (!serverSGetGraphRes.success || !serverSGetGraphRes.graph) {
+                devLog(`✗ Check: Failed to fetch session S graph from server: ${serverSGetGraphRes.message}`);
+                return;
+            }
+            const serverSGraph = serverSGetGraphRes.graph;
+
+            const sGraphsEqual = graphsAreEquivalent({ graphA: localSGraph, graphB: serverSGraph });
+            if (sGraphsEqual) {
+                devLog('✓ Check: Session Keystone (S) dependency graphs are equivalent on client and server.');
+            } else {
+                devLog('✗ Check: Session Keystone (S) dependency graphs mismatch between client and server!');
+                return;
+            }
+
+            devLog('🎉 ALL PHASE 3B TRANSACTION SYNC CHECKS PASSED FLAWLESSLY! ✓');
+            btn.textContent = '✓ 3B All Passed';
+
+        } catch (error) {
+            devLog(`✗ 3B Check FAILED: ${extractErrorMsg(error)}`);
+            console.error(`${lc_fn} 3B Check error:`, error);
+        }
+    });
+}
+
 // ---------------------------------------------------------------------------
 // Dev Tools UI Init
 // ---------------------------------------------------------------------------
@@ -534,6 +1211,15 @@ export function initDevTools(): void {
         initCreateSessionKeystoneButton();
         initEvolveDomainKeystoneButton();
         initPerformSyncButton();
+        init1bSetupButton();
+        init1bSyncButton();
+        init1bCheckButton();
+        init2bSetupButton();
+        init2bSyncButton();
+        init2bCheckButton();
+        init3bSetupButton();
+        init3bSyncButton();
+        init3bCheckButton();
     } catch (error) {
         console.error(`${lc_fn} ${extractErrorMsg(error)}`);
     }