@ibgib/core-gib 0.1.11 → 0.1.12

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

@@ -1,6 +1,6 @@
 /**
  * @module sync-innerspace.respec
- * 
+ *
  * Verifies SyncSagaCoordinator using InnerSpace (in-memory/local) spaces.
  * This avoids disk I/O issues and focuses on the synchronization logic.
  */
@@ -18,6 +18,7 @@ import { Metaspace_Innerspace } from '../witness/space/metaspace/metaspace-inner
 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';
+import { getDependencyGraph } from '../common/other/graph-helper.mjs';
 
 const logalot = true;
 const lc = `[sync-innerspace.respec]`;
@@ -28,11 +29,10 @@ await respecfully(sir, `Sync InnerSpaces`, async () => {
     let sourceSpace: InnerSpace_V1;
     let destSpace: InnerSpace_V1;
 
-    // Setup before each test? Or once? 
+    // 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({
@@ -113,32 +113,177 @@ await respecfully(sir, `Sync InnerSpaces`, async () => {
             identity
         });
 
-        // 5. Verify Dest
-        console.log(`${lc} Verifying Destination...`);
+        // 5. Verify Dest (Full Dependency Graph)
+        console.log(`${lc} Verifying Destination (Full Graph)...`);
 
-        // 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.`);
+        // We expect the graph to contain: 
+        // 1. childWithRel
+        // 2. child (past of childWithRel)
+        // 3. root (ancestor of child, past of child)
+        // 4. stone (linked to childWithRel)
+        // 5. primitives (timeline_root, child, stone_data, identity, fork, mut8, rel8, root^gib, etc.)
 
-        // 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.`);
+        // Let's get the graph from the source first to know what to expect (ground truth)
+        const sourceGraph = await getDependencyGraph({
+            ibGibs: [childWithRel],
+            space: sourceSpace,
+        });
+        const sourceAddrs = Object.keys(sourceGraph);
+        console.log(`${lc} Source Graph Size: ${sourceAddrs.length}`);
+
+        // Now get the graph from the destination
+        const destGraph = await getDependencyGraph({
+            ibGibs: [childWithRel],
+            space: destSpace,
+        });
+        const destAddrs = Object.keys(destGraph);
+        console.log(`${lc} Dest Graph Size: ${destAddrs.length}`);
+
+        // Assert
+        iReckon(sir, destAddrs.length).asTo('dest graph size').isGonnaBe(sourceAddrs.length);
+
+        for (const addr of sourceAddrs) {
+            const inDest = !!destGraph[addr];
+            if (!inDest) {
+                console.error(`${lc} Missing in dest: ${addr}`);
+            }
+            iReckon(sir, inDest).asTo(`addr present in dest: ${addr}`).isGonnaBeTrue();
+        }
+
+        console.log(`${lc} Verified Full Dependency Graph synced.`);
+    });
+
+    await ifWe(sir, `Idempotency (No-op if already synced)`, async () => {
+        // 1. Setup Spaces
+        const 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; },
+        });
+
+        const sourceSpace = new InnerSpace_V1({ name: 'source_idem', uuid: 'source_idem_uuid' } as any);
+        await (sourceSpace as any).initialize();
+
+        const destSpace = new InnerSpace_V1({ name: 'dest_idem', uuid: 'dest_idem_uuid' } as any);
+        await (destSpace as any).initialize();
+
+        // 2. Seed Source and Sync ONCE
+        const root = await createTimelineRootHelper({
+            ib: 'timeline_root',
+            data: { type: 'root', n: 0 },
+            space: sourceSpace,
+        });
+
+        const mockKeystone = await getTestKeystoneServiceHelper();
+        const identity = await (mockKeystone as any).getIdentity();
+        const coordinator = new SyncSagaCoordinator(mockKeystone);
+
+        console.log(`${lc} Running First Sync...`);
+        await coordinator.sync({
+            source: sourceSpace,
+            dest: destSpace,
+            domainIbGibs: [root],
+            identity
+        });
+
+        // Verify Initial State
+        const rootAddr = getIbGibAddr({ ibGib: root });
+        const getRoot1 = await getFromSpace({ space: destSpace, addr: rootAddr });
+        iReckon(sir, getRoot1.success).asTo('First Sync success').isGonnaBeTrue();
 
-        // 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.`);
+        // 3. Run Sync AGAIN (Should be No-op)
+        console.log(`${lc} Running Second Sync...`);
+        await coordinator.sync({
+            source: sourceSpace,
+            dest: destSpace,
+            domainIbGibs: [root],
+            identity
+        });
+
+        // 4. Verify State Unchanged / Still Valid
+        const getRoot2 = await getFromSpace({ space: destSpace, addr: rootAddr });
+        iReckon(sir, getRoot2.success).asTo('Second Sync success').isGonnaBeTrue();
+
+        // Ensure no duplication or errors in destination (checking count in dependency graph might be good proxy?)
+        const destGraph = await getDependencyGraph({
+            ibGibs: [root],
+            space: destSpace,
+        });
+        iReckon(sir, Object.keys(destGraph).length).asTo('Dest Graph Size unchanged').isGonnaBe(Object.keys(destGraph).length); // Trivial assertion, mostly checking for no throw
+
+        console.log(`${lc} Verified Idempotency.`);
+    });
+
+    await ifWeMight(sir, `Dest Ahead (Pull/Fast-Backward)`, async () => {
+        // 1. Setup Spaces
+        const 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; },
+        });
+
+        const sourceSpace = new InnerSpace_V1({ name: 'source_pull', uuid: 'source_pull_uuid' } as any);
+        await (sourceSpace as any).initialize();
+
+        const destSpace = new InnerSpace_V1({ name: 'dest_pull', uuid: 'dest_pull_uuid' } as any);
+        await (destSpace as any).initialize();
+
+        // 2. Setup Initial Shared State
+        // Create root in Source, Sync to Dest
+        console.log(`${lc} Seeding initial shared state...`);
+        const root = await createTimelineRootHelper({
+            ib: 'timeline_pull',
+            data: { type: 'root', n: 0, state: 'initial' },
+            space: sourceSpace,
+        });
+        const rootAddr = getIbGibAddr({ ibGib: root });
+
+        const mockKeystone = await getTestKeystoneServiceHelper();
+        const identity = await (mockKeystone as any).getIdentity();
+        const coordinator = new SyncSagaCoordinator(mockKeystone);
+
+        await coordinator.sync({
+            source: sourceSpace,
+            dest: destSpace,
+            domainIbGibs: [root],
+            identity
+        });
+
+        // 3. Evolve DESTINATION (Simulate external update)
+        // We act "as if" we are on Dest side evolving it
+        console.log(`${lc} Evolving Destination (making Source behind)...`);
+        const childDest = await mut8Timeline({
+            timeline: root, // works because mut8Timeline just needs the ib/data/rel8ns/n, doesn't need to be "in" the space object-wise, but we persist to destSpace
+            mut8Opts: { dataToAddOrPatch: { n: 1, state: 'ahead' } },
+            metaspace,
+            space: destSpace,
+        });
+        const childDestAddr = getIbGibAddr({ ibGib: childDest });
+
+        // Verify Source DOES NOT have childDest
+        const getChildInSource = await getFromSpace({ space: sourceSpace, addr: childDestAddr });
+        iReckon(sir, getChildInSource.success).asTo('Source is behind').isGonnaBeFalse(); // Or success=true/addrsNotFound depending on impl
+
+        // 4. Run Sync from Source
+        // Checks:
+        // - Source should detect it is behind (or "conflict" in current generic terms).
+        // - Source should Pull 'childDest' from Dest.
+        // - Source should update itself.
+        console.log(`${lc} Running Sync (Pull)...`);
+        await coordinator.sync({
+            source: sourceSpace,
+            dest: destSpace,
+            domainIbGibs: [root], // We start with what Source knows (root)
+            identity
+        });
 
-        // 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.`);
+        // 5. Verify Source Caught Up
+        const getChildInSourcePost = await getFromSpace({ space: sourceSpace, addr: childDestAddr });
+        iReckon(sir, getChildInSourcePost.success).asTo('Source pulled new frame').isGonnaBeTrue();
+        iReckon(sir, getChildInSourcePost.ibGibs?.[0]).asTo('Source has childDest').isGonnaBeTruthy();
 
+        console.log(`${lc} Verified Dest Ahead / Pull.`);
     });
 });

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

@@ -9,24 +9,22 @@ import {
     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 { IbGib_V1, IbGibData_V1 } from '@ibgib/ts-gib/dist/V1/types.mjs';
+import { GLOBAL_LOG_A_LOT } from '../core-constants.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, getFromSpace } from '../witness/space/space-helper.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
+    createTimeline, mut8Timeline, getHistory, appendToTimeline
 } 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';
+import { resetInnerSpaces } from '../witness/space/metaspace/metaspace-innerspace/metaspace-innerspace-helper.mjs';
+
+const logalot = GLOBAL_LOG_A_LOT;
 
-const maam = `[${import.meta.url}]`, sir = maam;
 
 interface TestData extends IbGibData_V1 {
     note?: string;
@@ -40,11 +38,12 @@ respecfully(sir, `[timeline-api]`, async () => {
     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 null; },
+            getFnPromptPassword: () => async (title, msg) => { console.log(`[PromptPwd] ${title}: ${msg}`); return 'password'; },
         });
         space = metaspace.zeroSpace as InnerSpace_V1;
     });
@@ -165,7 +164,8 @@ respecfully(sir, `[timeline-api]`, async () => {
         const concurrencyLevels = [1, 2, 5, 50];
 
         for (const N of concurrencyLevels) {
-            console.log(`[Stress Test] Testing concurrency level: ${N}`);
+            if (logalot) { console.log(`[Stress Test] Testing concurrency level: ${N}`); }
+
 
             // Arrange: Baseline
             let tInitial = (await createTimeline<TestData>({
@@ -179,8 +179,26 @@ respecfully(sir, `[timeline-api]`, async () => {
             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>({
@@ -191,7 +209,7 @@ respecfully(sir, `[timeline-api]`, async () => {
                     space,
                     mut8Opts: {
                         dataToAddOrPatch: {
-                            uniq: i, // distinct data to ensure unique hashes if needed
+                            uniqueId: uniqueIdsForUniqueTransforms.pop(),
                         }
                     }
                     // No skipLock! We want them to contend.
@@ -225,7 +243,7 @@ respecfully(sir, `[timeline-api]`, async () => {
                 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}`);
+                if (logalot) { console.log(`[Stress Test] [N=${N}] SUCCESS. Final n=${latestIbGib.data!.n}`); }
 
             } catch (err) {
                 console.error(`[Stress Test] [N=${N}] FAILED:`, 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-innerspace/metaspace-innerspace-helper.mts

@@ -10,7 +10,39 @@ 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,
@@ -74,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) {
@@ -103,9 +133,9 @@ export const fnDtoToSpace: DtoToSpaceFunction = async (spaceDto) => {
             if (!spaceDto.data) { throw new Error(`invalid spaceDto. InnerSpace_V1 should have truthy data. (E: d402fda7a6a53668b655c2885029a423)`); }
             // 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 {
@@ -113,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

@@ -16,6 +16,7 @@ import { InnerSpace_V1 } from '../../../../witness/space/inner-space/inner-space
 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;
 
@@ -24,6 +25,7 @@ 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}`); },
@@ -32,17 +34,17 @@ respecfully(sir, `[metaspace-innerspace]`, async () => {
         });
     });
 
-    await ifWeMight(sir, `can instantiate`, async () => {
+    await ifWe(sir, `can instantiate`, async () => {
         iReckon(sir, metaspace).asTo('metaspace').isGonnaBeTruthy();
         iReckon(sir, metaspace.initialized).asTo('initialized').isGonnaBeTrue();
     });
 
-    await ifWeMight(sir, `has zeroSpace`, async () => {
+    await ifWe(sir, `has zeroSpace`, async () => {
         const zs = metaspace.zeroSpace;
         iReckon(sir, zs).asTo('zeroSpace').isGonnaBeTruthy();
     });
 
-    await ifWeMight(sir, `can createTimeline and track latest`, async () => {
+    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.
 

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({