@ibgib/space-gib 0.0.1 → 0.0.2

package/src/client/dev-tools.mts

@@ -10,21 +10,25 @@
  * 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-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 { 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';
 
 const logalot = GLOBAL_LOG_A_LOT
 const lc = '[dev-tools]';
@@ -35,6 +39,8 @@ interface DebugState {
     targetX?: IbGib_V1;
     sessionS?: KeystoneIbGib_V1;
     sessionSecret?: string;
+    senderPeer?: SyncPeerWebSocketSender_V1;
+    sagaId?: string;
 }
 
 export const debugState: DebugState = {};
@@ -276,19 +282,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,
@@ -394,7 +400,7 @@ function initEvolveDomainKeystoneButton(): void {
 }
 
 // ---------------------------------------------------------------------------
-// Perform Sync Handshake (S) button
+// Perform Sync Connect (S) button
 // ---------------------------------------------------------------------------
 
 function initPerformSyncButton(): void {
@@ -406,7 +412,7 @@ function initPerformSyncButton(): void {
         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 +429,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 +470,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 +492,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 +523,578 @@ function initPerformSyncButton(): void {
     });
 }
 
+// ---------------------------------------------------------------------------
+// Phase 1B: Standardized Setup / Sync / Check testing loop
+// ---------------------------------------------------------------------------
+
+function init1bSetupButton(): void {
+    const lc_fn = `${lc}[init1bSetupButton]`;
+    const btn = document.getElementById('btn-1b-setup') as HTMLButtonElement | null;
+    if (!btn) return;
+
+    btn.addEventListener('click', async () => {
+        try {
+            btn.disabled = true;
+            devLog('1B 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."); }
+
+            const masterSecret = 'test-sender-secret-phase1';
+            const keystoneService = new KeystoneService_V1();
+
+            // 1. Create Genesis Domain Keystone (I^Itjp) in local sourceSpace
+            const domainI = await keystoneService.genesis({
+                masterSecret,
+                configs: [
+                    getSpaceGibPoolConfig('sync', 'senderidentitysyncsaltphase1'),
+                    getSpaceGibPoolConfig('manage', 'senderidentitymanagesaltphase1'),
+                ],
+                metaspace,
+                space,
+                frameDetails: { client: 'space-gib-web-dev', timestamp: getTimestamp() }
+            });
+
+            debugState.domainI = domainI;
+            debugState.domainIMasterSecret = masterSecret;
+
+            devLog(`1B Setup: ✓ Domain Keystone (I) created locally: ${getIbGibAddr({ ibGib: domainI })}`);
+            devLog(`1B 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(`1B Setup: ✓ Domain Keystone registered and stored on receiver (server).`);
+            } else {
+                devLog(`1B Setup: X postGenesisKeystone failed: ${resGenesis.message}.`);
+                throw new Error(`1B Setup: Server rejected genesis domain keystone: ${resGenesis.message}`);
+            }
+
+            // 3. Create Test IbGib (X) locally
+            const resX = await factory.firstGen({
+                parentIbGib: ROOT,
+                ib: 'test data',
+                data: { hello: 'world', random: Math.random() },
+                dna: true,
+                nCounter: true,
+                tjp: { uuid: true, timestamp: true }
+            });
+            debugState.targetX = resX.newIbGib;
+            devLog(`1B Setup: ✓ Target (X) created locally: ${getIbGibAddr({ ibGib: resX.newIbGib })}`);
+
+            devLog('✓ 1B Setup Complete! Ready for 1B Sync.');
+            btn.textContent = '✓ 1B Setup Complete';
+
+            // Enable next button in the phase flow
+            const syncBtn = document.getElementById('btn-1b-sync') as HTMLButtonElement | null;
+            if (syncBtn) syncBtn.disabled = false;
+
+        } catch (error) {
+            devLog(`✗ 1B Setup FAILED: ${extractErrorMsg(error)}`);
+            console.error(`${lc_fn} 1B Setup error:`, error);
+            btn.disabled = false;
+        }
+    });
+}
+
+function init1bSyncButton(): void {
+    const lc_fn = `${lc}[init1bSyncButton]`;
+    const btn = document.getElementById('btn-1b-sync') as HTMLButtonElement | null;
+    if (!btn) return;
+
+    btn.addEventListener('click', async () => {
+        try {
+            btn.disabled = true;
+            devLog('1B Sync: Executing senderCoordinator.sync(...) using WebSocket Peer...');
+
+            const domainI = debugState.domainI;
+            const targetX = debugState.targetX;
+            if (!domainI || !targetX) {
+                devLog('⚠ 1B 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."); }
+
+            // Instantiate WebSocket sender peer
+            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 {
+                // Execute sync saga — triggers establishSessionIdentity internally!
+                const syncSaga = await coordinator.sync({
+                    domainIbGibs: [targetX],
+                    senderIdentity: domainI,
+                    fnSenderSecret: async () => debugState.domainIMasterSecret!,
+                    peer: senderPeer,
+                    localSpace: space,
+                    metaspace,
+                    conflictStrategy: 'optimisticWithLCS' as any
+                });
+                await syncSaga.done;
+            } catch (err) {
+                // connection/sync error is fine/expected right now since connection is in Phase 2
+                devLog(`1B Sync: Coordinator sync executed (establish phase successfully run; connection/sync errors expected in 1B): ${extractErrorMsg(err)}`);
+            }
+
+            devLog('✓ 1B Sync Execution Complete! Ready for State Checks.');
+            btn.textContent = '✓ 1B Sync Run';
+
+            // Enable check button
+            const checkBtn = document.getElementById('btn-1b-check') as HTMLButtonElement | null;
+            if (checkBtn) checkBtn.disabled = false;
+
+        } catch (error) {
+            devLog(`✗ 1B Sync FAILED: ${extractErrorMsg(error)}`);
+            console.error(`${lc_fn} 1B Sync error:`, error);
+            btn.disabled = false;
+        }
+    });
+}
+
+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 lc_fn = `${lc}[init2bSetupButton]`;
+    const btn = document.getElementById('btn-2b-setup') as HTMLButtonElement | null;
+    if (!btn) return;
+
+    btn.addEventListener('click', async () => {
+        try {
+            btn.disabled = true;
+            devLog('2B 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."); }
+
+            const masterSecret = 'test-sender-secret-phase2';
+            const keystoneService = new KeystoneService_V1();
+
+            // 1. Create Genesis Domain Keystone (I^Itjp) in local sourceSpace
+            const domainI = await keystoneService.genesis({
+                masterSecret,
+                configs: [
+                    getSpaceGibPoolConfig('sync', 'senderidentitysyncsaltphase2'),
+                    getSpaceGibPoolConfig('manage', 'senderidentitymanagesaltphase2'),
+                ],
+                metaspace,
+                space,
+                frameDetails: { client: 'space-gib-web-dev', timestamp: getTimestamp() }
+            });
+
+            debugState.domainI = domainI;
+            debugState.domainIMasterSecret = masterSecret;
+
+            devLog(`2B Setup: ✓ Domain Keystone (I) created locally: ${getIbGibAddr({ ibGib: domainI })}`);
+            devLog(`2B 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(`2B Setup: ✓ Domain Keystone registered and stored on receiver (server).`);
+            } else {
+                devLog(`2B Setup: X postGenesisKeystone failed: ${resGenesis.message}.`);
+                throw new Error(`2B Setup: Server rejected genesis domain keystone: ${resGenesis.message}`);
+            }
+
+            // 3. Create Test IbGib (X) locally
+            const resX = await factory.firstGen({
+                parentIbGib: ROOT,
+                ib: 'test data',
+                data: { hello: 'world2', random: Math.random() },
+                dna: true,
+                nCounter: true,
+                tjp: { uuid: true, timestamp: true }
+            });
+            debugState.targetX = resX.newIbGib;
+            devLog(`2B Setup: ✓ Target (X) created locally: ${getIbGibAddr({ ibGib: resX.newIbGib })}`);
+
+            devLog('✓ 2B Setup Complete! Ready for 2B Sync.');
+            btn.textContent = '✓ 2B Setup Complete';
+
+            // Enable next button in the phase flow
+            const syncBtn = document.getElementById('btn-2b-sync') as HTMLButtonElement | null;
+            if (syncBtn) syncBtn.disabled = false;
+
+        } catch (error) {
+            devLog(`✗ 2B Setup FAILED: ${extractErrorMsg(error)}`);
+            console.error(`${lc_fn} 2B Setup error:`, error);
+            btn.disabled = false;
+        }
+    });
+}
+
+function init2bSyncButton(): void {
+    const lc_fn = `${lc}[init2bSyncButton]`;
+    const btn = document.getElementById('btn-2b-sync') as HTMLButtonElement | null;
+    if (!btn) return;
+
+    btn.addEventListener('click', async () => {
+        try {
+            btn.disabled = true;
+            devLog('2B Sync: Executing senderCoordinator.sync(...) using WebSocket Peer...');
+
+            const domainI = debugState.domainI;
+            const targetX = debugState.targetX;
+            if (!domainI || !targetX) {
+                devLog('⚠ 2B 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."); }
+
+            // Instantiate WebSocket sender peer
+            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 {
+                // Execute sync saga — triggers establishSessionIdentity and connectImpl internally!
+                const syncSaga = await coordinator.sync({
+                    domainIbGibs: [targetX],
+                    senderIdentity: domainI,
+                    fnSenderSecret: async () => debugState.domainIMasterSecret!,
+                    peer: senderPeer,
+                    localSpace: space,
+                    metaspace,
+                    conflictStrategy: 'optimisticWithLCS' as any
+                });
+                await syncSaga.done;
+            } catch (err) {
+                // connection/sync error is fine/expected right now since sync protocol (Phase 3) might be incomplete
+                devLog(`2B Sync: Coordinator sync executed (connect phase successfully run; subsequent sync errors expected in 2B): ${extractErrorMsg(err)}`);
+            }
+
+            devLog('✓ 2B Sync Execution Complete! Ready for State Checks.');
+            btn.textContent = '✓ 2B Sync Run';
+
+            // Enable check button
+            const checkBtn = document.getElementById('btn-2b-check') as HTMLButtonElement | null;
+            if (checkBtn) checkBtn.disabled = false;
+
+        } catch (error) {
+            devLog(`✗ 2B Sync FAILED: ${extractErrorMsg(error)}`);
+            console.error(`${lc_fn} 2B Sync error:`, error);
+            btn.disabled = false;
+        }
+    });
+}
+
+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 init3bPlaceholder(): void {
+    const btnSetup = document.getElementById('btn-3b-setup') as HTMLButtonElement | null;
+    const btnSync = document.getElementById('btn-3b-sync') as HTMLButtonElement | null;
+    const btnCheck = document.getElementById('btn-3b-check') as HTMLButtonElement | null;
+
+    if (btnSetup) {
+        btnSetup.addEventListener('click', () => devLog('3B Setup: Placeholders ready for Phase 3B (Transactional Sync).'));
+    }
+    if (btnSync) {
+        btnSync.addEventListener('click', () => devLog('3B Sync: Placeholders ready for Phase 3B (Transactional Sync).'));
+    }
+    if (btnCheck) {
+        btnCheck.addEventListener('click', () => devLog('3B Check: Placeholders ready for Phase 3B (Transactional Sync).'));
+    }
+}
+
 // ---------------------------------------------------------------------------
 // Dev Tools UI Init
 // ---------------------------------------------------------------------------
@@ -534,6 +1112,13 @@ export function initDevTools(): void {
         initCreateSessionKeystoneButton();
         initEvolveDomainKeystoneButton();
         initPerformSyncButton();
+        init1bSetupButton();
+        init1bSyncButton();
+        init1bCheckButton();
+        init2bSetupButton();
+        init2bSyncButton();
+        init2bCheckButton();
+        init3bPlaceholder();
     } catch (error) {
         console.error(`${lc_fn} ${extractErrorMsg(error)}`);
     }