@ibgib/core-gib 0.1.10 → 0.1.12

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

@@ -0,0 +1,255 @@
+/**
+ * @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';
+const maam = `[${import.meta.url}]`, sir = maam;
+import { getUUID } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+import { IbGibData_V1 } from '@ibgib/ts-gib/dist/V1/types.mjs';
+import { getIbGibAddr } from '@ibgib/ts-gib/dist/helper.mjs';
+
+import { GLOBAL_LOG_A_LOT } from '../core-constants.mjs';
+import { InnerSpace_V1 } from '../witness/space/inner-space/inner-space-v1.mjs';
+import { getLatestAddrs, getFromSpace } from '../witness/space/space-helper.mjs';
+import {
+    createTimeline, mut8Timeline, getHistory, appendToTimeline
+} from './timeline-api.mjs';
+import { Metaspace_Innerspace } from '../witness/space/metaspace/metaspace-innerspace/metaspace-innerspace.mjs';
+import { resetInnerSpaces } from '../witness/space/metaspace/metaspace-innerspace/metaspace-innerspace-helper.mjs';
+
+const logalot = GLOBAL_LOG_A_LOT;
+
+
+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 () => {
+        resetInnerSpaces();
+        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 'password'; },
+        });
+        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) {
+            if (logalot) { 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)
+            console.log(`already had addr for fork expected (I: 585a392f1c5aa0eedc1aedd8bbc31325)`);
+
+            // Act: Launch N mutations simultaneously
+            /**
+             * I'm getting output (warnings?) that the transform ibgib addr
+             * already exists. This stems from the fact that dna/transform
+             * ibgibs do not have timestamps or anything, they simply are
+             * memoized args to the transform functions. So we need something 
+             * unique _in the arg itself_, which in this case means in the
+             * `dataToAddOrPatch` field.
+             * 
+             * Note, however, that it is expected for the original `fork`
+             * transform that created tInitial to be common and for it to
+             * already have this fork dna ibgib. But this shouldn't happen for
+             * each mut8 transform. 
+             */
+            const uniqueIdsForUniqueTransforms: string[] = [];
+            for (let i = 0; i < N; i++) {
+                uniqueIdsForUniqueTransforms.push(await getUUID());
+            }
+            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: {
+                            uniqueId: uniqueIdsForUniqueTransforms.pop(),
+                        }
+                    }
+                    // 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);
+
+                if (logalot) { 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/inner-space/inner-space-v1.mts

@@ -1,7 +1,6 @@
 import { clone, extractErrorMsg, groupBy, pretty } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
 import { IbGibAddr } from '@ibgib/ts-gib/dist/types.mjs';
 import { getIbGibAddr, } from '@ibgib/ts-gib/dist/helper.mjs';
-import { IbGib_V1, getGib, } from '@ibgib/ts-gib/dist/V1/index.mjs';
 import { validateIbGibIntrinsically } from '@ibgib/ts-gib/dist/V1/validate-helper.mjs';
 
 import { GLOBAL_LOG_A_LOT } from '../../../core-constants.mjs';
@@ -14,6 +13,8 @@ import { getSpaceIb, } from '../space-helper.mjs';
 import { getTjpAddr } from '../../../common/other/ibgib-helper.mjs';
 import { ReconciliationSpaceBase, ReconciliationSpaceData, ReconciliationSpaceRel8ns } from '../reconciliation-space/reconciliation-space-base.mjs';
 import { DEFAULT_INNER_SPACE_DATA_V1, InnerSpaceData_V1, InnerSpaceRel8ns_V1 } from './inner-space-types.mjs';
+import { IbGib_V1 } from '@ibgib/ts-gib/dist/V1/types.mjs';
+import { getGib } from '@ibgib/ts-gib/dist/V1/transforms/transform-helper.mjs';
 
 const logalot = GLOBAL_LOG_A_LOT;
 
@@ -197,7 +198,7 @@ export class InnerSpace_V1<
 
             if (addrsAlreadyHave.length > 0) {
                 resultData.addrsAlreadyHave = addrsAlreadyHave;
-                resultData.warnings = (resultData.warnings || []).concat([`${lc} already had addr(s).`]);
+                resultData.warnings = (resultData.warnings || []).concat([`${lc} already had addr(s): ${addrsAlreadyHave.join('|')}`]);
             }
             resultData.success = true;
         } catch (error) {
@@ -321,7 +322,8 @@ export class InnerSpace_V1<
                     const timeline = ibGibsInSpaceByTjp[tjpAddr];
 
                     if (timeline.some(ibGib => ibGib.data?.n === undefined)) {
-                        console.warn(`${lc} timeline includes ibgibs with ibGib.data?.n === undefined (W: 7360a8e81b05accf244fb4b86e796325)`);
+                        const filtered = timeline.filter(ibGib => ibGib.data?.n === undefined);
+                        console.warn(`${lc} timeline includes ibgibs with ibGib.data?.n === undefined.\nfiltered:\n${filtered.map(x => pretty(x)).join('\n')}}(W: 7360a8e81b05accf244fb4b86e796325)`);
                     }
                     // sort mutates array in place
                     timeline.sort((a, b) => (a.data?.n ?? -1) > (b.data?.n ?? -1) ? 1 : -1); // sorts ascending, e.g., 0,1,2...[Highest]

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,7 +9,40 @@ 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 } = {};
+
+const innerSpaces: { [spaceId: string]: IbGibSpaceAny } = {};
+
+/**
+ * Extracts the spaceId from the ib string.
+ *
+ * ib format: `witness space [classname] [name] [id] [type] [subtype]`
+ */
+export function getSpaceIdFromIb(ib: string): string {
+    if (!ib) { throw new Error(`ib required. (E: 7c28c8e1a8a24345bb344155b4131422)`); }
+    const parts = ib.split(' ');
+    // witness space classname name id ...
+    // 0       1     2         3    4
+    if (parts.length < 5) { throw new Error(`invalid space ib format: ${ib} (E: 14a84497e59648949822067786481223)`); }
+    return parts[4];
+}
+
+/**
+ * Manually registers a space in the module-level registry.
+ * Use this when creating spaces outside of the standard factory functions
+ * (e.g. via direct constructor calls) to ensure they are resolvable by DTO.
+ */
+export const registerInnerSpace = (space: IbGibSpaceAny) => {
+    const spaceId = getSpaceIdFromIb(space.ib);
+    innerSpaces[spaceId] = space;
+}
+
+/**
+ * Resets the internal registry of spaces.
+ * USE FOR TESTING ONLY.
+ */
+export const resetInnerSpaces = () => {
+    Object.keys(innerSpaces).forEach(key => delete innerSpaces[key]);
+}
 
 export const fnCreateNewLocalSpace: LocalSpaceFactoryFunction = async ({
     allowCancel,
@@ -73,9 +106,7 @@ Enter space name:
         if (newLocalSpace.gib === GIB) { throw new Error(`localSpace.gib not updated correctly.`); }
         if (logalot) { console.log(`${lc} localSpace.gib: ${newLocalSpace.gib} (after sha256v1)`); }
 
-        const gibInfo = getGibInfo({ gib: newLocalSpace.gib });
-        const tjpGib = gibInfo.tjpGib ?? newLocalSpace.gib!;
-        innerSpaces[tjpGib] = newLocalSpace;
+        registerInnerSpace(newLocalSpace as IbGibSpaceAny);
 
         return newLocalSpace as IbGibSpaceAny;
     } catch (error) {
@@ -96,14 +127,15 @@ 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!;
-            const existingSpace = innerSpaces[tjpGib];
+            const spaceId = getSpaceIdFromIb(spaceDto.ib);
+            // console.log(`${lc} spaceDto.gib: ${spaceDto.gib}\ninnerSpaces keys:\n${Object.keys(innerSpaces).join('\n')}`);
+            const existingSpace = innerSpaces[spaceId];
             if (existingSpace) {
                 return existingSpace;
             } else {
@@ -111,9 +143,8 @@ export const fnDtoToSpace: DtoToSpaceFunction = async (spaceDto) => {
                 console.warn(`${lc} in memory innerspace dto that isnt' the reference to the object itself in memory, and we don't have it in the inner spaces map? i guess we'll create a new one from the dto (W: b8973f3a43f546eeaf59f60331896e75)`)
                 let space = new InnerSpace_V1(spaceDto.data as InnerSpaceData_V1, spaceDto.rel8ns);
                 await space.initialized;
-                const gibInfo = getGibInfo({ gib: space.gib });
-                const tjpGib = gibInfo.tjpGib ?? space.gib!;
-                innerSpaces[tjpGib] = space;
+
+                registerInnerSpace(space);
                 return space;
             }
         }

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

@@ -12,7 +12,7 @@ import { IbGibSpaceAny } from '../../../../witness/space/space-base-v1.mjs';
 import { InnerSpace_V1 } from '../../../../witness/space/inner-space/inner-space-v1.mjs';
 import { IbGibCacheService } from '../../../../common/cache/cache-types.mjs';
 import { MetaspaceFactory } from '../metaspace-types.mjs';
-import { fnCreateNewLocalSpace, fnDtoToSpace } from './metaspace-innerspace-helper.mjs';
+import { fnCreateNewLocalSpace, fnDtoToSpace, registerInnerSpace } from './metaspace-innerspace-helper.mjs';
 import { MetaspaceBase } from '../metaspace-base.mjs';
 
 const logalot = GLOBAL_LOG_A_LOT;
@@ -75,6 +75,7 @@ export class Metaspace_Innerspace extends MetaspaceBase {
                     const zeroSpace = new InnerSpace_V1(/*initialData*/ undefined as any, /*initialRel8ns*/ undefined);
                     zeroSpace.gib = 'gib';
                     this._zeroSpace = zeroSpace;
+                    registerInnerSpace(this._zeroSpace);
                     return zeroSpace;
                 }
             };

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

@@ -0,0 +1,92 @@
+/**
+ * @module metaspace-innerspace.respec
+ *
+ * specs for the in-memory metaspace implementation.
+ */
+
+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 { getIbGibAddr } from '@ibgib/ts-gib/dist/helper.mjs';
+import { InnerSpace_V1 } from '../../../../witness/space/inner-space/inner-space-v1.mjs';
+import { Metaspace_Innerspace } from './metaspace-innerspace.mjs';
+import { createTimeline, mut8Timeline } from '../../../../timeline/timeline-api.mjs';
+import { MetaspaceService } from '../metaspace-types.mjs';
+import { resetInnerSpaces } from './metaspace-innerspace-helper.mjs';
+
+const maam = `[${import.meta.url}]`, sir = maam;
+
+respecfully(sir, `[metaspace-innerspace]`, async () => {
+
+    let metaspace: Metaspace_Innerspace;
+
+    firstOfEach(sir, async () => {
+        resetInnerSpaces();
+        metaspace = new Metaspace_Innerspace(undefined); // no cache for now
+        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; },
+        });
+    });
+
+    await ifWe(sir, `can instantiate`, async () => {
+        iReckon(sir, metaspace).asTo('metaspace').isGonnaBeTruthy();
+        iReckon(sir, metaspace.initialized).asTo('initialized').isGonnaBeTrue();
+    });
+
+    await ifWe(sir, `has zeroSpace`, async () => {
+        const zs = metaspace.zeroSpace;
+        iReckon(sir, zs).asTo('zeroSpace').isGonnaBeTruthy();
+    });
+
+    await ifWe(sir, `can createTimeline and track latest`, async () => {
+        // This implicitly tests getLatestAddr/s via timeline-api usage if we were using it,
+        // but here we call it directly or via minimal timeline op.
+
+        // 1. Create a timeline via timeline-api using this metaspace
+        const resCreate = await createTimeline({
+            space: metaspace.zeroSpace,
+            metaspace: metaspace,
+            data: { n: 0 },
+            ib: 'timeline'
+        });
+        const t0 = resCreate.newIbGib;
+        const t0Addr = getIbGibAddr({ ibGib: t0 });
+
+        // 2. Verify we can get latest addr
+        // Ideally metaspace should track this automatically if registerNewIbGib is called inside createTimeline,
+        // which calls metaspace.registerNewIbGib.
+
+        // Note: timeline-api calls metaspace.registerNewIbGib.
+        // So we check if metaspace has it.
+
+        const latestAddr = await metaspace.getLatestAddr({
+            ibGib: t0,
+            space: metaspace.zeroSpace,
+        });
+
+        iReckon(sir, latestAddr).asTo('latestAddr matches initial').isGonnaBe(t0Addr);
+
+        // 3. Mutate
+        const t1 = await mut8Timeline({
+            timeline: t0,
+            metaspace,
+            space: metaspace.zeroSpace,
+            mut8Opts: { dataToAddOrPatch: { n: 1 } }
+        });
+        const t1Addr = getIbGibAddr({ ibGib: t1 });
+
+        // 4. Verify latest addr updated
+        const latestAddr2 = await metaspace.getLatestAddr({
+            ibGib: t0, // asking about t0's latest
+            space: metaspace.zeroSpace,
+        });
+        iReckon(sir, latestAddr2).asTo('latestAddr2 matches mutated').isGonnaBe(t1Addr);
+    });
+
+});

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

@@ -51,7 +51,6 @@ import { validateBootstrapIbGib } from './bootstrap/bootstrap-helper.mjs';
 import { BootstrapData, BootstrapIbGib, BootstrapRel8ns } from './bootstrap/bootstrap-types.mjs';
 import { newUpMetaStone } from '../../common/meta-stone/meta-stone-helper.mjs';
 import { WITNESS_ATOM } from '../witness-constants.mjs';
-import { SyncSpaceIbGib } from './outer-space/outer-space-types.mjs';
 
 let logalot = GLOBAL_LOG_A_LOT;
 
@@ -1620,6 +1619,7 @@ async function createRootIbGib({
             linkedRel8ns: [Rel8n.past, Rel8n.ancestor],
             tjp: { uuid: true, timestamp: true },
             dna: true,
+            nCounter: true,
         });
         const { newIbGib } = resNewIbGib;
         await persistTransformResult({