@ibgib/space-gib 0.0.3 → 0.0.5

package/src/client/dev-tools/base-tools.mts

@@ -0,0 +1,252 @@
+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 { KeystoneService_V1 } from '@ibgib/core-gib/dist/keystone/keystone-service-v1.mjs';
+import { 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 { KEYSTONE_VERB_CONNECT, POOL_ID_CONNECT } from '@ibgib/core-gib/dist/keystone/keystone-constants.mjs';
+import { getGlobalMetaspace_waitIfNeeded } from "@ibgib/web-gib/dist/helpers.mjs";
+import { SESSION_KEYSTONE_POLICY, getConnectChallenge } from "../../common/keystone-policies.mjs";
+import { SpaceGibApiBridge } from '../api/space-gib-api-bridge.mjs';
+
+import { debugState, devLog, lc } from './common.mjs';
+
+let _ws: WebSocket | null = null;
+
+export function initWsTestButton(): void {
+    const lc_fn = `${lc}[initWsTestButton]`;
+    const btn = document.getElementById('btn-test-ws') as HTMLButtonElement | null;
+    if (!btn) {
+        console.warn(`${lc_fn} btn-test-ws not found — skipping`);
+        return;
+    }
+
+    btn.addEventListener('click', () => {
+        try {
+            if (_ws && _ws.readyState === WebSocket.OPEN) {
+                _ws.send(JSON.stringify({ ping: 'hello from client', ts: Date.now() }));
+                devLog('→ sent ping on existing connection');
+                return;
+            }
+
+            const protocol = location.protocol === 'https:' ? 'wss:' : 'ws:';
+            const wsUrl = `${protocol}//${location.host}/api/debug/ws-echo`;
+            devLog(`→ connecting to ${wsUrl}`);
+
+            _ws = new WebSocket(wsUrl);
+
+            _ws.addEventListener('open', () => {
+                devLog('✓ WebSocket connected');
+                btn.textContent = 'Send WS Ping';
+            });
+
+            _ws.addEventListener('message', (ev) => {
+                devLog(`← ${ev.data}`);
+            });
+
+            _ws.addEventListener('close', (ev) => {
+                devLog(`✗ WebSocket closed (code ${ev.code})`);
+                btn.textContent = 'Test WebSocket';
+                _ws = null;
+            });
+
+            _ws.addEventListener('error', (ev) => {
+                devLog(`✗ WebSocket error — check console`);
+                console.error(`${lc_fn} WebSocket error`, ev);
+            });
+
+        } catch (error) {
+            devLog(`✗ ${extractErrorMsg(error)}`);
+            console.error(`${lc_fn} ${extractErrorMsg(error)}`);
+        }
+    });
+}
+
+export function initPrintStateButton(): void {
+    const btn = document.getElementById('btn-print-dev-state') as HTMLButtonElement | null;
+    if (!btn) { return; }
+    btn.addEventListener('click', () => {
+        devLog(`Printing debug state to console...`);
+        console.dir(debugState);
+    });
+}
+
+export function initCreateDomainKeystoneButton(): void {
+    const lc_fn = `${lc}[initCreateDomainKeystoneButton]`;
+    const btn = document.getElementById('btn-create-domain-keystone') as HTMLButtonElement | null;
+    if (!btn) { return; }
+
+    btn.addEventListener('click', async () => {
+        try {
+            btn.disabled = true;
+            devLog('Generating dummy Domain Keystone (I)...');
+
+            const metaspace = await getGlobalMetaspace_waitIfNeeded();
+            const space = await metaspace.getLocalUserSpace({});
+            if (!space) { throw new Error("No default space found in metaspace."); }
+
+            const masterSecret = 'password';
+            const keystoneService = new KeystoneService_V1();
+
+            const domainI = await keystoneService.genesis({
+                masterSecret,
+                configs: [
+                    createManagePoolConfig({
+                        id: 'default',
+                        salt: await getUUID(),
+                        replenishStrategy: KeystoneReplenishStrategy.topUp,
+                    }),
+                ],
+                metaspace,
+                space,
+                frameDetails: { client: 'space-gib-web-dev', timestamp: getTimestamp() }
+            });
+
+            const iAddr = getIbGibAddr({ ibGib: domainI });
+            devLog(`✓ Local genesis complete: ${iAddr}`);
+
+            debugState.domainI = domainI;
+            debugState.domainIMasterSecret = masterSecret;
+
+            devLog(`Posting genesis keystone to server...`);
+            const apiBridge = new SpaceGibApiBridge();
+            const resSync = await apiBridge.postGenesisKeystone(domainI);
+            if (!resSync.success) {
+                devLog(`✗ Server rejected genesis keystone: ${resSync.message}`);
+                btn.disabled = false;
+                return;
+            }
+
+            devLog(`✓ Server accepted Domain Keystone (I)`);
+            btn.textContent = '✓ Domain Keystone Created';
+
+            const nextBtn = document.getElementById('btn-create-test-ibgib') as HTMLButtonElement;
+            if (nextBtn) { nextBtn.disabled = false; }
+
+        } catch (error) {
+            devLog(`✗ ${extractErrorMsg(error)}`);
+            console.error(`${lc_fn} ${extractErrorMsg(error)}`);
+            btn.disabled = false;
+        }
+    });
+}
+
+export function initCreateTestIbGibButton(): void {
+    const lc_fn = `${lc}[initCreateTestIbGibButton]`;
+    const btn = document.getElementById('btn-create-test-ibgib') as HTMLButtonElement | null;
+    if (!btn) {
+        console.warn(`${lc_fn} btn-create-test-ibgib not found — skipping`);
+        return;
+    }
+
+    btn.addEventListener('click', async () => {
+        try {
+            devLog('Generating dummy X^Xtjp ibgib...');
+            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 }
+            });
+            const xIbGib = resX.newIbGib;
+            const xAddr = getIbGibAddr({ ibGib: xIbGib });
+
+            debugState.targetX = xIbGib;
+            devLog(`✓ Created X: ${xAddr}`);
+            btn.textContent = '✓ Test IbGib (X) Created';
+
+            const nextBtn = document.getElementById('btn-create-session-keystone') as HTMLButtonElement;
+            if (nextBtn) { nextBtn.disabled = false; }
+        } catch (error) {
+            devLog(`✗ ${extractErrorMsg(error)}`);
+            console.error(`${lc_fn} ${extractErrorMsg(error)}`);
+        }
+    });
+}
+
+export function initCreateSessionKeystoneButton(): void {
+    const lc_fn = `${lc}[initCreateSessionKeystoneButton]`;
+    const btn = document.getElementById('btn-create-session-keystone') as HTMLButtonElement | null;
+    if (!btn) {
+        console.warn(`${lc_fn} btn-create-session-keystone not found — skipping`);
+        return;
+    }
+
+    btn.addEventListener('click', async () => {
+        try {
+            devLog('Generating Session Keystone (S^Stjp)...');
+
+            const domainI = debugState.domainI;
+            const targetX = debugState.targetX;
+
+            if (!domainI) { devLog('⚠ No domain keystone (I) found in state. Please Create Domain Keystone first.'); return; }
+            if (!targetX) { devLog('⚠ No target ibgib (X) found in state. Please Create Test IbGib first.'); return; }
+
+            const metaspace = await getGlobalMetaspace_waitIfNeeded();
+            const space = await metaspace.getLocalUserSpace({});
+            if (!space) { throw new Error("No default space found in metaspace."); }
+
+            const sessionSecret = 'ephemeral-' + Math.random().toString();
+            const keystoneService = new KeystoneService_V1();
+
+            console.warn(`${lc}[NAG] placeholder genesis keystone config right now (W: 69b108687cf8bec0f9a8e148bcca8d26)`);
+            const sIbGib = await keystoneService.genesis({
+                masterSecret: sessionSecret,
+                configs: [
+                    {
+                        id: SESSION_KEYSTONE_POLICY.DEFAULT_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.DEFAULT_POOL.SIZE,
+                            replenish: SESSION_KEYSTONE_POLICY.COMMON.REPLENISH,
+                            selectSequentially: SESSION_KEYSTONE_POLICY.DEFAULT_POOL.SELECT_SEQUENTIALLY,
+                            selectRandomly: SESSION_KEYSTONE_POLICY.DEFAULT_POOL.SELECT_RANDOMLY,
+                            targetBindingCount: SESSION_KEYSTONE_POLICY.DEFAULT_POOL.TARGET_BINDING_COUNT,
+                        },
+                        allowedVerbs: [],
+                    },
+                    {
+                        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.CONNECT_POOL.SIZE,
+                            replenish: SESSION_KEYSTONE_POLICY.COMMON.REPLENISH,
+                            selectSequentially: SESSION_KEYSTONE_POLICY.CONNECT_POOL.SELECT_SEQUENTIALLY,
+                            selectRandomly: SESSION_KEYSTONE_POLICY.CONNECT_POOL.SELECT_RANDOMLY,
+                            targetBindingCount: SESSION_KEYSTONE_POLICY.CONNECT_POOL.TARGET_BINDING_COUNT,
+                        },
+                        allowedVerbs: [SESSION_KEYSTONE_POLICY.CONNECT_POOL.VERB],
+                    }
+                ],
+                metaspace,
+                space,
+                frameDetails: {
+                    client: 'space-gib-web-session',
+                    target_I: domainI ? getIbGibAddr({ ibGib: domainI }) : undefined,
+                    target_X: targetX ? getIbGibAddr({ ibGib: targetX }) : undefined,
+                }
+            });
+
+            const sAddr = getIbGibAddr({ ibGib: sIbGib });
+            debugState.sessionS = sIbGib;
+            debugState.sessionSecret = sessionSecret;
+
+            devLog(`✓ Created Session Keystone: ${sAddr}`);
+            btn.textContent = '✓ Session Keystone Created';
+        } catch (error) {
+            devLog(`✗ ${extractErrorMsg(error)}`);
+            console.error(`${lc_fn} ${extractErrorMsg(error)}`);
+        }
+    });
+}
+

package/src/client/dev-tools/common.mts

@@ -0,0 +1,217 @@
+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 { KeystoneIbGib_V1 } from '@ibgib/core-gib/dist/keystone/keystone-types.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 { getGlobalMetaspace_waitIfNeeded } from "@ibgib/web-gib/dist/helpers.mjs";
+import { SESSION_KEYSTONE_POLICY, getSpaceGibPoolConfig } from "../../common/keystone-policies.mjs";
+import { SpaceGibApiBridge } from '../api/space-gib-api-bridge.mjs';
+import { SyncConflictStrategy } from '@ibgib/core-gib/dist/sync/sync-constants.mjs';
+import { GLOBAL_LOG_A_LOT } from '../constants.mjs';
+
+export const logalot = GLOBAL_LOG_A_LOT;
+export const lc = '[dev-tools]';
+
+export interface DebugState {
+    domainI?: KeystoneIbGib_V1;
+    domainIMasterSecret?: string;
+    targetX?: IbGib_V1;
+    targetC1?: IbGib_V1;
+    targetC2?: IbGib_V1;
+    sessionS?: KeystoneIbGib_V1;
+    sessionSecret?: string;
+    senderPeer?: SyncPeerWebSocketSender_V1;
+    sagaId?: string;
+}
+
+export const debugState: DebugState = {};
+(window as any).ibgibDebugState = debugState;
+
+// ---------------------------------------------------------------------------
+// Dev panel log helper
+// ---------------------------------------------------------------------------
+
+export function devLog(msg: string): void {
+    const logEl = document.getElementById('dev-panel-log') as HTMLPreElement | null;
+    if (!logEl) { return; }
+    const timestamp = new Date().toISOString().slice(11, 23); // HH:MM:SS.mmm
+    logEl.textContent = `[${timestamp}] ${msg}\n` + logEl.textContent;
+}
+
+// ---------------------------------------------------------------------------
+// Phase Setup / Sync common runners
+// ---------------------------------------------------------------------------
+
+export interface PhaseSetupOptions {
+    phaseText: '1B' | '2B' | '3B' | '4.1B' | '4.2B' | '4.3B';
+    btnId: string;
+    nextBtnId: string;
+    masterSecret: string;
+    syncSalt: string;
+    manageSalt: string;
+    ib: string;
+    data: any;
+}
+
+export 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`;
+
+        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;
+    }
+}
+
+export interface PhaseSyncOptions {
+    phaseText: '1B' | '2B' | '3B' | '4.1B' | '4.2B' | '4.3B';
+    btnId: string;
+    nextBtnId: string;
+    expectSyncFailure?: boolean;
+    failureMessageSuffix?: string;
+}
+
+export 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;
+    }
+}

package/src/client/dev-tools/phase-1.mts

@@ -0,0 +1,156 @@
+import { extractErrorMsg } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+import { getIbGibAddr } from '@ibgib/ts-gib/dist/helper.mjs';
+import { KeystoneIbGib_V1 } from '@ibgib/core-gib/dist/keystone/keystone-types.mjs';
+import { 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 { SpaceGibApiBridge } from '../api/space-gib-api-bridge.mjs';
+
+import { debugState, devLog, lc, performPhaseSetup, performPhaseSync } from './common.mjs';
+
+export 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() }
+        });
+    });
+}
+
+export 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'
+        });
+    });
+}
+
+export 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...');
+
+            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!;
+
+            // 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})`);
+            }
+
+            // 3. Verify Server-Side (receiver) registrations via GET REST API
+            devLog('Check: Verifying registrations on server (receiver metaspace)...');
+            const apiBridge = new SpaceGibApiBridge();
+
+            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; }
+            }
+
+        } catch (error) {
+            devLog(`✗ 1B Check FAILED: ${extractErrorMsg(error)}`);
+            console.error(`${lc_fn} 1B Check error:`, error);
+        }
+    });
+}