@ibgib/core-gib 0.1.10 → 0.1.11

package/src/agent-helpers.mts

@@ -6,47 +6,132 @@
  * actions for creating and modifying data.
  */
 
+import { extractErrorMsg, getUUID } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
 import { IbGib_V1, IbGibRel8ns_V1, IbGibData_V1 } from '@ibgib/ts-gib/dist/V1/types.mjs';
-import { IbGibAddr, Ib } from '@ibgib/ts-gib/dist/types.mjs';
+
+import { GLOBAL_LOG_A_LOT } from './core-constants.mjs';
 import { KeystoneService_V1 } from './keystone/keystone-service-v1.mjs';
 import { IbGibSpaceAny } from './witness/space/space-base-v1.mjs';
+import { Factory_V1 } from '@ibgib/ts-gib/dist/V1/factory.mjs';
+import { createTimeline } from './timeline/timeline-api.mjs';
+import { persistTransformResult, registerNewIbGib } from './witness/space/space-helper.mjs';
+import { MetaspaceService } from './witness/space/metaspace/metaspace-types.mjs';
+import { TransformResult } from '@ibgib/ts-gib/dist/types.mjs';
+
+const logalot = GLOBAL_LOG_A_LOT;
 
 /**
  * Creates a "Stone" ibGib - an immutable, primitive-like data record with no history/timeline.
  * Useful for static data, configurations, or standalone records.
  */
-export async function createStoneHelper<TData = any>(opts: {
+export async function createStoneHelper<TData extends IbGibData_V1 = any>({
+    ib,
+    data,
+    rel8ns,
+    uuid,
+    noTimestamp,
+}: {
     ib: string;
     data?: TData;
     rel8ns?: IbGibRel8ns_V1;
     uuid?: boolean; // If true, generates a UUID in data
+    noTimestamp?: boolean;
 }): Promise<IbGib_V1<TData>> {
-    throw new Error("Not implemented yet. Agent waiting for user implementation.");
+    const lc = `[${createStoneHelper.name}]`;
+    try {
+        if (logalot) { console.log(`${lc} starting... (I: e4b15ee74de22ec9a917c578adc83425)`); }
+
+        if (!ib) { throw new Error(`ib required (E: 3d5df8fd5b880e0e0dcedd37dbc3f825)`); }
+
+        // the parent primitive ib is almost always the atom of the ib.
+        const atom = ib.split(' ').at(0)!;
+
+        if (uuid) {
+            if (!data) { data = {} as TData; }
+            data.uuid = await getUUID();
+        }
+
+        const stone = await Factory_V1.stone({
+            parentPrimitiveIb: atom,
+            ib,
+            data,
+            rel8ns,
+            uuid,
+        });
+
+        return stone;
+    } catch (error) {
+        console.error(`${lc} ${extractErrorMsg(error)}`);
+        throw error;
+    } finally {
+        if (logalot) { console.log(`${lc} complete.`); }
+    }
 }
 
 /**
  * Creates a new "Living" Timeline Root.
  * This is the starting point for any mutable data structure (a file, a user profile, a post).
  */
-export async function createTimelineRootHelper<TData = any>(opts: {
+export async function createTimelineRootHelper<TData extends IbGibData_V1 = any>({
+    ib,
+    data,
+    space,
+}: {
     ib: string;     // e.g. "comment" or "task"
     data?: TData;   // Initial data
     space: IbGibSpaceAny; // Where to persist this new root
 }): Promise<IbGib_V1<TData>> {
-    throw new Error("Not implemented yet. Agent waiting for user implementation.");
-}
+    const lc = `[${createTimelineRootHelper.name}]`;
+    try {
+        if (logalot) { console.log(`${lc} starting... (I: 8f50a8cf0268742048f7c188feb5a825)`); }
 
-/**
- * Forks an existing timeline to create a new version (a child).
- * Used for updating data, adding a comment to a thread (if threading via timeline), etc.
- */
-export async function forkTimelineHelper<TData = any>(opts: {
-    timeline: IbGib_V1<TData>; // The current tip of the timeline
-    dataToAddOrPatch?: Partial<TData>;
-    rel8nsToAdd?: IbGibRel8ns_V1; // e.g. linking to another ibGib
-    space: IbGibSpaceAny;
-}): Promise<IbGib_V1<TData>> {
-    throw new Error("Not implemented yet. Agent waiting for user implementation.");
+        // const resTimeline = await createTimeline({
+        //     ib,
+        //     data,
+        //     rel8ns: undefined,
+        //     metaspace, space
+        // });
+        // const timeline = resTimeline.newIbGib;
+
+        // return timeline;
+
+        // Determine the parent to fork based on the provided options.
+        const atom = ib.split(' ').at(0)!;
+        const parentIbGib = Factory_V1.primitive({ ib: atom });
+
+        const resNew = await Factory_V1.firstGen<TData>({
+            parentIbGib,
+            ib,
+            data,
+            rel8ns: undefined,
+            // these options are what make this a "timeline"
+            dna: true,
+            nCounter: true,
+            tjp: { timestamp: true, uuid: true },
+        });
+
+        // Persist the new timeline and its DNA to the designated space.
+        await persistTransformResult({ resTransform: resNew, space });
+        await registerNewIbGib({
+            ibGib: resNew.newIbGib,
+            space,
+            /**
+             * We don't need to broadcast here because it's a new, independent
+             * timeline, so there are no listeners yet.
+             */
+            fnBroadcast: undefined,
+        });
+
+        // We don't need to lock here because it's a new, independent timeline,
+        // so there are no concurrency concerns yet.
+
+        return resNew.newIbGib as IbGib_V1<TData>;
+    } catch (error) {
+        console.error(`${lc} ${extractErrorMsg(error)}`);
+        throw error;
+    } finally {
+        if (logalot) { console.log(`${lc} complete.`); }
+    }
 }
 
 /**
@@ -54,5 +139,21 @@ export async function forkTimelineHelper<TData = any>(opts: {
  * This mocks the identity and signing logic needed for Sync operations.
  */
 export async function getTestKeystoneServiceHelper(): Promise<KeystoneService_V1> {
-    throw new Error("Not implemented yet. Agent waiting for user implementation.");
+    class MockKeystoneService extends KeystoneService_V1 {
+        async getIdentity(): Promise<any> {
+            // Return a dummy identity
+            // We use the Factory directly here to just get *something* that looks like an ibgib
+            const res = await Factory_V1.firstGen({
+                parentIbGib: Factory_V1.primitive({ ib: 'identity' }),
+                ib: 'identity',
+                data: { uuid: await getUUID() },
+                dna: true,
+            });
+            return res.newIbGib;
+        }
+        // Implement other methods as no-ops or simple mocks
+        async sign(args: any): Promise<any> { return args.latestKeystone; /* minimal mock */ }
+        async verify(args: any): Promise<any> { return []; /* no errors */ }
+    }
+    return new MockKeystoneService() as unknown as KeystoneService_V1;
 }

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

@@ -0,0 +1,144 @@
+/**
+ * @module sync-innerspace.respec
+ * 
+ * Verifies SyncSagaCoordinator using InnerSpace (in-memory/local) spaces.
+ * This avoids disk I/O issues and focuses on the synchronization logic.
+ */
+
+import {
+    respecfully, lastOfAll, ifWe, iReckon,
+    ifWeMight
+} from '@ibgib/helper-gib/dist/respec-gib/respec-gib.mjs';
+const maam = `[${import.meta.url}]`, sir = maam;
+
+import { getIbGibAddr } from '@ibgib/ts-gib/dist/helper.mjs';
+import { SyncSagaCoordinator } from './sync-saga-coordinator.mjs';
+import { putInSpace, getFromSpace } from '../witness/space/space-helper.mjs';
+import { Metaspace_Innerspace } from '../witness/space/metaspace/metaspace-innerspace/metaspace-innerspace.mjs';
+import { InnerSpace_V1 } from '../witness/space/inner-space/inner-space-v1.mjs';
+import { createStoneHelper, createTimelineRootHelper, getTestKeystoneServiceHelper } from '../agent-helpers.mjs';
+import { mut8Timeline, appendToTimeline } from '../timeline/timeline-api.mjs';
+
+const logalot = true;
+const lc = `[sync-innerspace.respec]`;
+
+await respecfully(sir, `Sync InnerSpaces`, async () => {
+
+    let metaspace: Metaspace_Innerspace;
+    let sourceSpace: InnerSpace_V1;
+    let destSpace: InnerSpace_V1;
+
+    // Setup before each test? Or once? 
+    // For now, let's just do it inside the test block to be safe/simple.
+
+    await ifWe(sir, `Basic Push Sync (Source -> Dest)`, async () => {
+        // await ifWeMight(sir, `Basic Push Sync (Source -> Dest)`, async () => {
+        // 1. Setup Spaces
+        metaspace = new Metaspace_Innerspace(undefined);
+        await metaspace.initialize({
+            getFnAlert: () => async ({ title, msg }) => { console.log(`[Alert] ${title}: ${msg}`); },
+            getFnPrompt: () => async ({ title, msg }) => { console.log(`[Prompt] ${title}: ${msg}`); return ''; },
+            getFnPromptPassword: () => async (title, msg) => { console.log(`[PromptPwd] ${title}: ${msg}`); return null; },
+        });
+
+        // Create two distinct inner spaces manually or via metaspace if supported
+        // Metaspace_Innerspace typically manages one local user space, but we can instantiate InnerSpace_V1 directly.
+        sourceSpace = new InnerSpace_V1({ name: 'source', uuid: 'source_uuid' } as any);
+        await (sourceSpace as any).initialize();
+
+        destSpace = new InnerSpace_V1({ name: 'dest', uuid: 'dest_uuid' } as any);
+        await (destSpace as any).initialize();
+
+        // 2. Seed Source Data
+
+        // 2.1 Create a "Stone"
+        console.log(`${lc} Creating Stone...`);
+        const stone = await createStoneHelper({
+            ib: 'stone_data',
+            data: { some: 'data' },
+        });
+        const stoneAddr = getIbGibAddr({ ibGib: stone });
+        await putInSpace({ space: sourceSpace, ibGibs: [stone] });
+
+        // 2.2 Create a "Living" Timeline (Root)
+        console.log(`${lc} Creating Timeline Root...`);
+        const root = await createTimelineRootHelper({
+            ib: 'timeline_root',
+            data: { type: 'root', n: 0 },
+            space: sourceSpace,
+        });
+        const rootAddr = getIbGibAddr({ ibGib: root });
+
+        // 2.3 Evolve Timeline (Root -> Child)
+        // using mut8Timeline to simulate evolution
+        console.log(`${lc} Evolving Timeline...`);
+        const child = await mut8Timeline({
+            timeline: root,
+            mut8Opts: {
+                dataToAddOrPatch: { type: 'child', n: 1 }
+            },
+            metaspace,
+            space: sourceSpace,
+            // We use skipLock=true for simplicity in single-threaded test setup if locking is complex,
+            // but timeline-api handles locking. Let's try default first.
+            // Actually InnerSpace locking might be no-op or simple.
+        });
+        const childAddr = getIbGibAddr({ ibGib: child });
+
+        // 2.4 Rel8 Child to Stone (Dependency)
+        console.log(`${lc} Linking Child to Stone...`);
+        const childWithRel = await appendToTimeline({
+            timeline: child,
+            rel8nInfos: [{
+                rel8nName: 'linked_stone',
+                ibGibs: [stone]
+            }],
+            metaspace,
+            space: sourceSpace,
+        });
+        const childWithRelAddr = getIbGibAddr({ ibGib: childWithRel });
+
+        // 3. Setup Sync Coordinator
+        console.log(`${lc} Setting up Coordinator...`);
+        const mockKeystone = await getTestKeystoneServiceHelper();
+        const identity = await (mockKeystone as any).getIdentity();
+        const coordinator = new SyncSagaCoordinator(mockKeystone);
+
+        // 4. Run Sync
+        console.log(`${lc} Running Sync...`);
+        const syncRes = await coordinator.sync({
+            source: sourceSpace,
+            dest: destSpace,
+            domainIbGibs: [childWithRel], // Sync starting from the tip
+            identity
+        });
+
+        // 5. Verify Dest
+        console.log(`${lc} Verifying Destination...`);
+
+        // Check Stone
+        const getStone = await getFromSpace({ space: destSpace, addr: stoneAddr });
+        iReckon(sir, getStone.success).asTo('getStone.success').isGonnaBeTrue();
+        iReckon(sir, getStone.ibGibs?.[0]).asTo('stone in dest').isGonnaBeTruthy();
+        console.log(`${lc} Verified Stone synced.`);
+
+        // Check Root (Dependency of Child)
+        const getRoot = await getFromSpace({ space: destSpace, addr: rootAddr });
+        iReckon(sir, getRoot.success).asTo('getRoot.success').isGonnaBeTrue();
+        iReckon(sir, getRoot.ibGibs?.[0]).asTo('root in dest').isGonnaBeTruthy();
+        console.log(`${lc} Verified Root synced.`);
+
+        // Check Child (Dependency of ChildWithRel)
+        const getChild = await getFromSpace({ space: destSpace, addr: childAddr });
+        iReckon(sir, getChild.success).asTo('getChild.success').isGonnaBeTrue();
+        iReckon(sir, getChild.ibGibs?.[0]).asTo('child in dest').isGonnaBeTruthy();
+        console.log(`${lc} Verified Child synced.`);
+
+        // Check ChildWithRel (The Tip)
+        const getChildWithRel = await getFromSpace({ space: destSpace, addr: childWithRelAddr });
+        iReckon(sir, getChildWithRel.success).asTo('getChildWithRel.success').isGonnaBeTrue();
+        iReckon(sir, getChildWithRel.ibGibs?.[0]).asTo('childWithRel in dest').isGonnaBeTruthy();
+        console.log(`${lc} Verified Timeline Tip synced.`);
+
+    });
+});

package/src/timeline/timeline-api.respec.mts

@@ -0,0 +1,237 @@
+/**
+ * @module timeline-api.respec
+ *
+ * specs for the high-level timeline api.
+ */
+
+import {
+    firstOfEach, firstOfAll, ifWe,
+    lastOfEach, lastOfAll,
+    ifWeMight, iReckon, respecfully, respecfullyDear
+} from '@ibgib/helper-gib/dist/respec-gib/respec-gib.mjs';
+
+import { IbGib_V1, IbGibData_V1 } from '@ibgib/ts-gib/dist/V1/types.mjs';
+import { InnerSpace_V1 } from '../witness/space/inner-space/inner-space-v1.mjs';
+import { DEFAULT_INNER_SPACE_DATA_V1 } from '../witness/space/inner-space/inner-space-types.mjs';
+import {
+    getLatestAddrs, persistTransformResult, registerNewIbGib, getFromSpace
+} from '../witness/space/space-helper.mjs';
+import { getIbGibAddr } from '@ibgib/ts-gib/dist/helper.mjs';
+import {
+    createTimeline, mut8Timeline, appendToTimeline, getHistory
+} from './timeline-api.mjs';
+import { MetaspaceService } from '../witness/space/metaspace/metaspace-types.mjs';
+import { IbGibAddr } from '@ibgib/ts-gib/dist/types.mjs';
+import { IbGibSpaceAny } from '../witness/space/space-base-v1.mjs';
+
+import { Metaspace_Innerspace } from '../witness/space/metaspace/metaspace-innerspace/metaspace-innerspace.mjs';
+
+const maam = `[${import.meta.url}]`, sir = maam;
+
+interface TestData extends IbGibData_V1 {
+    note?: string;
+    testId?: string;
+    uniq?: number;
+}
+
+respecfully(sir, `[timeline-api]`, async () => {
+
+    let space: InnerSpace_V1;
+    let metaspace: Metaspace_Innerspace;
+
+    firstOfEach(sir, async () => {
+        metaspace = new Metaspace_Innerspace(undefined);
+        await metaspace.initialize({
+            getFnAlert: () => async ({ title, msg }) => { console.log(`[Alert] ${title}: ${msg}`); },
+            getFnPrompt: () => async ({ title, msg }) => { console.log(`[Prompt] ${title}: ${msg}`); return ''; },
+            getFnPromptPassword: () => async (title, msg) => { console.log(`[PromptPwd] ${title}: ${msg}`); return null; },
+        });
+        space = metaspace.zeroSpace as InnerSpace_V1;
+    });
+
+    await ifWe(sir, `createTimeline`, async () => {
+        const res = await createTimeline<TestData>({
+            space,
+            metaspace,
+            data: { note: 'first timeline' },
+            ib: 'timeline',
+        });
+
+        const newTimeline = res.newIbGib;
+        iReckon(sir, newTimeline).asTo('newTimeline').isGonnaBeTruthy();
+        const addr = getIbGibAddr({ ibGib: newTimeline });
+
+        // verify persistence
+        const resGet = await getFromSpace({ addr, space });
+        iReckon(sir, resGet.success).asTo('persisted success').isGonnaBeTrue();
+        iReckon(sir, resGet.ibGibs![0]).asTo('persisted ibGib').isGonnaBe(newTimeline);
+    });
+
+    await ifWe(sir, `mut8Timeline`, async () => {
+        // Arrange
+        const resCreate = await createTimeline<TestData>({
+            space,
+            metaspace,
+            data: { note: 'orig' },
+            ib: 'timeline',
+        });
+        const timeline = resCreate.newIbGib;
+        console.log(`[mut8Timeline] created timeline n=${timeline.data!.n}`);
+        const initialPastLength = timeline.rel8ns?.past?.length || 0;
+        console.log(`[mut8Timeline] created timeline past length=${initialPastLength}`);
+
+        // Act
+        const mutatedTimeline = await mut8Timeline<TestData>({
+            timeline,
+            metaspace,
+            space,
+            mut8Opts: {
+                dataToAddOrPatch: { note: 'mutated' },
+            }
+        });
+        console.log(`[mut8Timeline] mutated timeline n=${mutatedTimeline.data!.n}`);
+
+
+        // Assert
+        iReckon(sir, mutatedTimeline).asTo('mutatedTimeline').isGonnaBeTruthy();
+        iReckon(sir, mutatedTimeline.data!.note).asTo('data.note').isGonnaBe('mutated');
+
+        // n should increment by 1
+        const expectedN = (timeline.data!.n || 0) + 1;
+        iReckon(sir, mutatedTimeline.data!.n).asTo('data.n').isGonnaBe(expectedN);
+
+        iReckon(sir, mutatedTimeline.rel8ns!.past).asTo('past').isGonnaBeTruthy();
+        // past length should include the previous frame + whatever it had
+        iReckon(sir, mutatedTimeline.rel8ns!.past!.length).asTo('past length').isGonnaBe(initialPastLength + 1);
+        iReckon(sir, mutatedTimeline.rel8ns!.past!.at(-1)).asTo('past addr').isGonnaBe(getIbGibAddr({ ibGib: timeline }));
+    });
+
+    await ifWe(sir, `appendToTimeline`, async () => {
+        // Arrange
+        const resCreate = await createTimeline<TestData>({
+            space,
+            metaspace,
+            data: { n: 0 },
+            ib: 'timeline',
+        });
+        let timeline = resCreate.newIbGib;
+        const rel8nInfos = [{
+            rel8nName: 'attachment',
+            ibGibs: [timeline] // just attaching itself as a test, weird but valid structure
+        }];
+        const timelinePastLength = timeline.rel8ns?.past?.length || 0;
+
+        // Act
+        const appendedTimeline = await appendToTimeline({
+            timeline,
+            rel8nInfos,
+            metaspace,
+            space,
+        });
+
+        // Assert
+        iReckon(sir, appendedTimeline).asTo('appendedTimeline').isGonnaBeTruthy();
+        iReckon(sir, appendedTimeline.rel8ns!.attachment).asTo('attachment').isGonnaBeTruthy();
+        iReckon(sir, appendedTimeline.rel8ns!.past?.length).asTo('past').isGonnaBe(timelinePastLength + 1);
+    });
+
+    await ifWe(sir, `getHistory`, async () => {
+        // Arrange
+        let t0 = (await createTimeline<TestData>({ space, metaspace, data: { n: 0 }, ib: 'timeline' })).newIbGib;
+        let t1 = await mut8Timeline<TestData>({ timeline: t0, metaspace, space, mut8Opts: { dataToAddOrPatch: { n: 1 } } });
+        let t2 = await mut8Timeline<TestData>({ timeline: t1, metaspace, space, mut8Opts: { dataToAddOrPatch: { n: 2 } } });
+
+        // Act
+        const history = await getHistory({
+            timeline: t2,
+            metaspace,
+            space,
+        });
+
+        // Assert
+        // t0 is actually 2nd frame (fork -> mut8).
+        // so history is [genesis, t0, t1]. length 3.
+        iReckon(sir, history.orderedPastIbGibs.length).asTo('history length').isGonnaBe(3);
+        // index 0 is genesis (the fork)
+        // index 1 is t0
+        // index 2 is t1
+        iReckon(sir, getIbGibAddr({ ibGib: history.orderedPastIbGibs[1] })).asTo('t0').isGonnaBe(getIbGibAddr({ ibGib: t0 }));
+        iReckon(sir, getIbGibAddr({ ibGib: history.orderedPastIbGibs[2] })).asTo('t1').isGonnaBe(getIbGibAddr({ ibGib: t1 }));
+        iReckon(sir, getIbGibAddr({ ibGib: history.headIbGib })).asTo('head').isGonnaBe(getIbGibAddr({ ibGib: t2 }));
+    });
+
+    await ifWe(sir, `Concurrency & Locking (Stress Test)`, async () => {
+        // const concurrencyLevels = [1, 2, 5, 50, 1000]; // too slow, because the locking mechanism doesn't scale well.
+        const concurrencyLevels = [1, 2, 5, 50];
+
+        for (const N of concurrencyLevels) {
+            console.log(`[Stress Test] Testing concurrency level: ${N}`);
+
+            // Arrange: Baseline
+            let tInitial = (await createTimeline<TestData>({
+                space,
+                metaspace,
+                data: { n: 0, testId: `concurrent-${N}` },
+                ib: 'timeline',
+            })).newIbGib;
+
+            // Initial state check
+            const initialN = (tInitial.data!.n || 0); // should be 1
+            const historyInitial = await getHistory({ timeline: tInitial, metaspace, space });
+            const initialHistoryLength = historyInitial.orderedPastIbGibs.length; // should be 1 (genesis)
+
+            // Act: Launch N mutations simultaneously
+            const promises: Promise<any>[] = [];
+            for (let i = 0; i < N; i++) {
+                promises.push(mut8Timeline<TestData>({
+                    timeline: tInitial, // All start referencing the same initial frame (or logically the timeline itself)
+                    // Note: In reality, if we pass the *same* object tInitial, mut8Timeline should
+                    // resolve the *latest* inside the function.
+                    metaspace,
+                    space,
+                    mut8Opts: {
+                        dataToAddOrPatch: {
+                            uniq: i, // distinct data to ensure unique hashes if needed
+                        }
+                    }
+                    // No skipLock! We want them to contend.
+                }));
+            }
+
+            try {
+                // Wait for all to complete
+                await Promise.all(promises);
+
+                // Verification
+                // 1. Get Latest Address
+                const resLatest = await getLatestAddrs({ ibGibs: [tInitial], space });
+                const latestAddr = resLatest.data!.latestAddrsMap![getIbGibAddr({ ibGib: tInitial })] as string;
+
+                iReckon(sir, latestAddr).asTo(`[N=${N}] latestAddr exists`).isGonnaBeTruthy();
+
+                // 2. Load the latest frame
+                const resGet = await getFromSpace({ addr: latestAddr, space });
+                const latestIbGib = resGet.ibGibs![0];
+
+                // 3. Verify data.n
+                // Initial n=1. We did N mutations.
+                // Each mutation increments nCounter.
+                const expectedN = initialN + N;
+                iReckon(sir, latestIbGib.data!.n).asTo(`[N=${N}] data.n should be ${expectedN}`).isGonnaBe(expectedN);
+
+                // 4. Verify Lineage (no divergence)
+                // History length should be initialHistoryLength + N
+                const history = await getHistory({ timeline: latestIbGib, metaspace, space });
+                const expectedHistoryLength = initialHistoryLength + N;
+                iReckon(sir, history.orderedPastIbGibs.length).asTo(`[N=${N}] history length`).isGonnaBe(expectedHistoryLength);
+
+                console.log(`[Stress Test] [N=${N}] SUCCESS. Final n=${latestIbGib.data!.n}`);
+
+            } catch (err) {
+                console.error(`[Stress Test] [N=${N}] FAILED:`, err);
+                throw err;
+            }
+        }
+    });
+
+});

package/src/witness/space/metaspace/metaspace-base.mts

@@ -1539,11 +1539,37 @@ export abstract class MetaspaceBase implements MetaspaceService {
             if (!resGetLatest) { throw new Error(`resGetLatest falsy (E: 3851bbe4427ae11771f222234e8c6622)`); }
             if (!resGetLatest.data) { throw new Error(`invalid resGetLatest: data falsy (E: 134e0f1f65edc69c6951c32e00a4bb22)`); }
             if (resGetLatest.data.success) {
-                if (resGetLatest.data.addrs?.length === 1) {
-                    return resGetLatest.data.addrs[0];
-                } else if (resGetLatest.data.addrsNotFound?.length === 1) {
-                    return undefined;
-                } else if (resGetLatest.data.addrsErrored?.length === 1) {
+                // Should have addrs map
+                const latestAddrsMap = resGetLatest.data.latestAddrsMap;
+                if (!latestAddrsMap) {
+                    // fallback to old way just in case? Or just error.
+                    // The error I saw had latestAddrsMap but no addrs.
+                    // So we should look at the map.
+                    if (resGetLatest.data.addrs?.length === 1) {
+                        return resGetLatest.data.addrs[0];
+                    } else if (resGetLatest.data.addrsNotFound?.length === 1) {
+                        return undefined;
+                    }
+                } else {
+                    // We have the map. Ideally we want the one entry.
+                    const keys = Object.keys(latestAddrsMap);
+                    if (keys.length === 1) {
+                        return latestAddrsMap[keys[0]] || undefined;
+                    } else if (keys.length === 0) {
+                        // could be not found?
+                        if (resGetLatest.data.addrsNotFound?.length === 1) {
+                            return undefined;
+                        } else {
+                            // If we didn't find it, and success is true, maybe it's just undefined?
+                            // But usually getLatestAddrs returns map entries for found ones.
+                            return undefined;
+                        }
+                    } else {
+                        throw new Error(`(UNEXPECTED) latestAddrsMap has multiple entries? We only asked for one. (E: 790518290f6b46729017684698539222)`);
+                    }
+                }
+
+                if (resGetLatest.data.addrsErrored?.length === 1) {
                     const emsg = resGetLatest.data.errors?.join('|') ?? "[unspecified error(s)] (E: 24f338036aa84ac99e3c39a660207222)";
                     throw new Error(`resGetLatest had error(s): ${emsg}`);
                 } else {

package/src/witness/space/metaspace/metaspace-innerspace/metaspace-innerspace-helper.mts

@@ -9,6 +9,7 @@ import { DEFAULT_LOCAL_SPACE_POLLING_INTERVAL_MS, } from "../../../../witness/sp
 import { InnerSpace_V1, } from "../../inner-space/inner-space-v1.mjs";
 import { InnerSpaceData_V1 } from "../../inner-space/inner-space-types.mjs";
 
+
 const innerSpaces: { [tjpGib: string]: IbGibSpaceAny } = {};
 
 export const fnCreateNewLocalSpace: LocalSpaceFactoryFunction = async ({
@@ -96,10 +97,11 @@ export const fnDtoToSpace: DtoToSpaceFunction = async (spaceDto) => {
         if ((spaceDto as InnerSpace_V1).ibGibs) {
             return spaceDto as InnerSpace_V1;
         } else {
-            console.log(`${lc} spaceDto: ${pretty(spaceDto)} (I: d69ab87f2fa8360ff8e60e78aa15c825)`);
+            // test is outputting a lot of these logs
+            // console.log(`${lc} spaceDto: ${pretty(spaceDto)} (I: d69ab87f2fa8360ff8e60e78aa15c825)`); // I want to keep this in if we need to turn the logging back on
 
             if (!spaceDto.data) { throw new Error(`invalid spaceDto. InnerSpace_V1 should have truthy data. (E: d402fda7a6a53668b655c2885029a423)`); }
-            console.dir(spaceDto);
+            // console.dir(spaceDto); // I want to keep this in if we need to turn the logging back on
 
             const gibInfo = getGibInfo({ gib: spaceDto.gib });
             const tjpGib = gibInfo.tjpGib ?? spaceDto.gib!;