@ibgib/core-gib 0.1.9 → 0.1.11

package/src/witness/space/inner-space/inner-space-v1.respec.mts

@@ -5,10 +5,11 @@ import {
 } 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 { IbGib_V1 } from '@ibgib/ts-gib/dist/V1/types.mjs';
-
+import { Factory_V1 } from '@ibgib/ts-gib/dist/V1/factory.mjs';
+import { mut8 } from '@ibgib/ts-gib/dist/V1/transforms/mut8.mjs';
+import { rel8 } from '@ibgib/ts-gib/dist/V1/transforms/rel8.mjs';
+import { fork } from '@ibgib/ts-gib/dist/V1/transforms/fork.mjs';
 import { getTjpAddr } from '../../../common/other/ibgib-helper.mjs';
-// import { SyncSpaceOptionsIbGib } from '../outer-space/outer-space-types.mjs';
 
 import {
     testSpace_createAndInit,
@@ -17,235 +18,187 @@ import {
     testSpace_registerNewIbGib_GetLatest,
 } from '../space-respec-helper.mjs';
 import { InnerSpace_V1, } from './inner-space-v1.mjs';
-import { createTimeline, getHistory, mut8Timeline } from '../../../timeline/timeline-api.mjs';
-import { MetaspaceService } from '../metaspace/metaspace-types.mjs';
-import { Metaspace_Innerspace } from '../metaspace/metaspace-innerspace/metaspace-innerspace.mjs';
-// import { getLatestAddrs, putInSpace } from '../space-helper.mjs';
+import { DEFAULT_INNER_SPACE_DATA_V1 } from './inner-space-types.mjs';
+import { putInSpace, getFromSpace } from '../space-helper.mjs';
 
 const logalot = true;
-/**
- * not sure where to put this, but we probably will want to reuse this in the
- * future (assuming it works)
- * @returns metaspace service reference
- */
-async function getNewInitializedInMemoryMetaspaceForTesting({
-    defaultSpaceName,
-}: {
-    defaultSpaceName: string,
-}): Promise<MetaspaceService> {
-    const lc = `[${getNewInitializedInMemoryMetaspaceForTesting.name}]`;
-    try {
-        if (logalot) { console.log(`${lc} starting... (I: 766d7596addcb73f4820586469233b25)`); }
-
-        let metaspace = new Metaspace_Innerspace(/*cacheSvc*/undefined);
-        if (logalot) { console.log(`${lc} creating metaspace complete. initializing... (I: 61b74d62e8832c9fa853e4b8c4c2d825)`); }
-
-        await metaspace.initialize({
-            spaceName: defaultSpaceName,
-            metaspaceFactory: undefined,
-            getFnAlert: () => { return async ({ title, msg }) => console.log(title, msg) },
-            getFnPrompt: () => {
-                return async ({ title, msg }) => {
-                    // if this is needed, we might set up some way for testing
-                    // to prepare either a queue of prompts or some kind of map
-                    // and put it on the metaspace itself
-                    throw new Error(`not implemented (E: c7ef688a02f8cb74487260f9274ac825)`);
-                    // promptForText({ title, msg, confirm: false });
-                }
-            },
-            getFnPromptPassword: () => {
-                return async () => {
-                    return 'password';
-                    // promptForSecret({ confirm: true })
-                }
-            },
+
+await respecfully(sir, `[${InnerSpace_V1.name} specs]`, async () => {
+
+    await testSpace_createAndInit({
+        respecfulTitle: sir,
+        // shortcircuitRespec: true,
+        fnGetInitialSpaceData: async () => {
+            return {
+                ...DEFAULT_INNER_SPACE_DATA_V1,
+                name: (await getUUID()).substring(0, 8),
+                uuid: await getUUID(),
+            };
+        },
+        fnGetInitialSpaceRel8ns: () => {
+            return Promise.resolve(undefined);
+        },
+        fnGetSpace: (initialData: any, initialRel8ns) => {
+            return Promise.resolve(new InnerSpace_V1(initialData, initialRel8ns));
+        },
+    })
+
+    await testSpace_putGetDelete({
+        respecfulTitle: sir,
+        // shortcircuitRespec: true,
+        fnGetInitialSpaceData: async () => {
+            return {
+                ...DEFAULT_INNER_SPACE_DATA_V1,
+                name: (await getUUID()).substring(0, 8),
+                uuid: await getUUID(),
+            };
+        },
+        fnGetInitialSpaceRel8ns: () => {
+            return Promise.resolve(undefined);
+        },
+        fnGetSpace: (initialData: any, initialRel8ns) => {
+            return Promise.resolve(new InnerSpace_V1(initialData, initialRel8ns));
+        },
+    });
+
+    await testSpace_persistTransformResult({
+        respecfulTitle: sir,
+        // shortcircuitRespec: true,
+        fnGetInitialSpaceData: async () => {
+            return {
+                ...DEFAULT_INNER_SPACE_DATA_V1,
+                name: (await getUUID()).substring(0, 8),
+                uuid: await getUUID(),
+            };
+        },
+        fnGetInitialSpaceRel8ns: () => {
+            return Promise.resolve(undefined);
+        },
+        fnGetSpace: (initialData: any, initialRel8ns) => {
+            return Promise.resolve(new InnerSpace_V1(initialData, initialRel8ns));
+        },
+    });
+
+    await testSpace_registerNewIbGib_GetLatest({
+        respecfulTitle: sir,
+        // shortcircuitRespec: true,
+        fnGetInitialSpaceData: async () => {
+            return {
+                ...DEFAULT_INNER_SPACE_DATA_V1,
+                name: (await getUUID()).substring(0, 8),
+                uuid: await getUUID(),
+            };
+        },
+        fnGetInitialSpaceRel8ns: () => {
+            return Promise.resolve(undefined);
+        },
+        fnGetSpace: (initialData: any, initialRel8ns) => {
+            return Promise.resolve(new InnerSpace_V1(initialData, initialRel8ns));
+        },
+        testLatestIterations: 5,
+    });
+
+    await respecfully(sir, 'Advanced Operations (mut8, rel8, fork)', async () => {
+
+        await ifWe(sir, 'should handle mut8 transform and persistence', async () => {
+            const space = new InnerSpace_V1(DEFAULT_INNER_SPACE_DATA_V1, undefined);
+            const gib = Factory_V1.primitive({ ib: 'gib' });
+
+            // 1. Create Origin
+            const resOrigin = await Factory_V1.firstGen({
+                ib: 'origin',
+                data: { initial: 'data' },
+                dna: true,
+                parentIbGib: gib,
+            });
+            const origin = resOrigin.newIbGib;
+
+            // 2. Mut8 (Mutate)
+            const resMut8 = await mut8({
+                src: origin,
+                dataToAddOrPatch: { mutated: 'data' },
+                dna: true,
+            });
+            const mutated = resMut8.newIbGib;
+
+            // 3. Put in space (should handle both if persisted correctly)
+            const resPut = await putInSpace({
+                space,
+                ibGibs: [origin, mutated],
+            });
+            iReckon(sir, resPut.success).isGonnaBeTrue();
+
+            // 4. Verify get
+            const resGet = await getFromSpace({
+                space,
+                addrs: [getIbGibAddr({ ibGib: mutated })],
+            });
+            iReckon(sir, resGet.success).isGonnaBeTrue();
+            // Using non-null assertion as we verified success
+            iReckon(sir, resGet.ibGibs![0].data!.mutated).isGonnaBe('data');
+        });
+
+        await ifWe(sir, 'should handle rel8 transform and persistence', async () => {
+            const space = new InnerSpace_V1(DEFAULT_INNER_SPACE_DATA_V1, undefined);
+            const gib = Factory_V1.primitive({ ib: 'gib' });
+
+            // 1. Create A and B
+            const resA = await Factory_V1.firstGen({ ib: 'A', dna: true, parentIbGib: gib });
+            const A = resA.newIbGib;
+            const resB = await Factory_V1.firstGen({ ib: 'B', dna: true, parentIbGib: gib });
+            const B = resB.newIbGib;
+            const bAddr = getIbGibAddr({ ibGib: B });
+
+            // 2. Rel8 A -> B (A links to B)
+            const resRel8 = await rel8({
+                src: A,
+                rel8nsToAddByAddr: { 'linked_to': [bAddr] },
+                dna: true,
+            });
+            const A_linked = resRel8.newIbGib;
+
+            // 3. Put in space
+            await putInSpace({
+                space,
+                ibGibs: [A, B, A_linked],
+            });
+
+            // 4. Verify relation
+            const resGet = await getFromSpace({
+                space,
+                addr: getIbGibAddr({ ibGib: A_linked }),
+            });
+            const retrieved = resGet.ibGibs![0];
+            iReckon(sir, retrieved.rel8ns!.linked_to).includes(bAddr);
         });
-        return metaspace;
-    } catch (error) {
-        console.error(`${lc} ${extractErrorMsg(error)}`);
-        throw error;
-    } finally {
-        if (logalot) { console.log(`${lc} complete.`); }
-    }
-}
-
-await respecfully(sir, 'metaspace setup itself', async () => {
-    await ifWe(sir, 'should init a metaspace', async () => {
-        const testSpaceName = 'TestSpaceName';
-
-        const metaspace = await getNewInitializedInMemoryMetaspaceForTesting({
-            defaultSpaceName: testSpaceName
+
+        await ifWe(sir, 'should handle fork persistence', async () => {
+            const space = new InnerSpace_V1(DEFAULT_INNER_SPACE_DATA_V1, undefined);
+            const gib = Factory_V1.primitive({ ib: 'gib' });
+
+            // 1. Create Root
+            const resRoot = await Factory_V1.firstGen({ ib: 'root', dna: true, parentIbGib: gib });
+            const root = resRoot.newIbGib;
+
+            // 2. Fork
+            const resFork = await fork({
+                src: root,
+                dna: true,
+                tjp: { timestamp: true },
+            });
+            const forkIbGib = resFork.newIbGib;
+
+            // 3. Put
+            await putInSpace({ space, ibGibs: [root, forkIbGib] });
+
+            // 4. Verify
+            const resGet = await getFromSpace({
+                space,
+                addr: getIbGibAddr({ ibGib: forkIbGib })
+            });
+            iReckon(sir, resGet.success).isGonnaBeTrue();
         });
 
-        iReckon(sir, metaspace.zeroSpace).asTo('metaspace should have a zero space').isGonnaBeTruthy();
     });
-});
 
-// await respecfully(sir, `[${InnerSpace_V1.name} specs]`, async () => {
-
-//     await testSpace_createAndInit({
-//         respecfulTitle: sir,
-//         // shortcircuitRespec: true,
-//         fnGetInitialSpaceData: async () => {
-//             return {
-//                 name: (await getUUID()).substring(0, 8),
-//                 uuid: await getUUID(),
-//             };
-//         },
-//         fnGetInitialSpaceRel8ns: () => {
-//             return Promise.resolve(undefined);
-//         },
-//         fnGetSpace: (initialData: any, initialRel8ns) => {
-//             return Promise.resolve(new InnerSpace_V1(initialData, initialRel8ns));
-//         },
-//     })
-
-//     await testSpace_putGetDelete({
-//         respecfulTitle: sir,
-//         // shortcircuitRespec: true,
-//         fnGetInitialSpaceData: async () => {
-//             return {
-//                 name: (await getUUID()).substring(0, 8),
-//                 uuid: await getUUID(),
-//             };
-//         },
-//         fnGetInitialSpaceRel8ns: () => {
-//             return Promise.resolve(undefined);
-//         },
-//         fnGetSpace: (initialData: any, initialRel8ns) => {
-//             return Promise.resolve(new InnerSpace_V1(initialData, initialRel8ns));
-//         },
-//     });
-
-//     await testSpace_persistTransformResult({
-//         respecfulTitle: sir,
-//         // shortcircuitRespec: true,
-//         fnGetInitialSpaceData: async () => {
-//             return {
-//                 name: (await getUUID()).substring(0, 8),
-//                 uuid: await getUUID(),
-//             };
-//         },
-//         fnGetInitialSpaceRel8ns: () => {
-//             return Promise.resolve(undefined);
-//         },
-//         fnGetSpace: (initialData: any, initialRel8ns) => {
-//             return Promise.resolve(new InnerSpace_V1(initialData, initialRel8ns));
-//         },
-//     });
-
-//     await testSpace_registerNewIbGib_GetLatest({
-//         respecfulTitle: sir,
-//         // shortcircuitRespec: true,
-//         fnGetInitialSpaceData: async () => {
-//             return {
-//                 name: (await getUUID()).substring(0, 8),
-//                 uuid: await getUUID(),
-//             };
-//         },
-//         fnGetInitialSpaceRel8ns: () => {
-//             return Promise.resolve(undefined);
-//         },
-//         fnGetSpace: (initialData: any, initialRel8ns) => {
-//             return Promise.resolve(new InnerSpace_V1(initialData, initialRel8ns));
-//         },
-//         testLatestIterations: 5,
-//     });
-
-// });
-
-
-
-// await respecfully(sir, 'reconciliation', async () => {
-//     const createSpace = async (name: string): Promise<InnerSpace_V1> => {
-//         const spaceData: InnerSpaceData_V1 = {
-//             name,
-//             classname: InnerSpace_V1.name,
-//             uuid: await getUUID(),
-//         };
-//         const space = new InnerSpace_V1(spaceData);
-//         await space.initialized;
-//         return space;
-//     };
-
-//     const testSpaceName = 'TestSpaceName';
-
-//     // common setup for reconciliation tests
-//     const metaspace: MetaspaceService = await getNewInitializedInMemoryMetaspaceForTesting({
-//         defaultSpaceName: testSpaceName
-//     });
-//     // const metaspace = new Metaspace_V1();
-//     // await metaspace.initialize();
-
-//     await ifWe(sir, 'should sync a new timeline to an empty destination space', async () => {
-//         // ARRANGE
-//         const local_space = await createSpace('local');
-//         const outer_space = await createSpace('outer');
-
-//         // Create a timeline in local_space using the new timeline-api
-//         const { newIbGib: timelineV1 } = await createTimeline({
-//             parentIb: 'test',
-//             ib: 'my test timeline',
-//             data: { foo: 'bar' },
-//             metaspace,
-//             space: local_space,
-//         });
-
-//         const timelineV2 = await mut8Timeline({
-//             timeline: timelineV1,
-//             mut8Opts: { dataToAddOrPatch: { foo: 'rab' } },
-//             metaspace,
-//             space: local_space,
-//         });
-
-//         // Get history for sync
-//         const historyInfo = await getHistory({
-//             timeline: timelineV2,
-//             includeDna: true,
-//             metaspace,
-//             space: local_space,
-//         });
-
-//         const timelineIbGibs = [
-//             ...(Object.values(historyInfo.dnaMap ?? {})),
-//             ...historyInfo.orderedPastIbGibs,
-//             historyInfo.headIbGib,
-//         ];
-//         const timelineAddrs = timelineIbGibs.map(x => getIbGibAddr({ ibGib: x }));
-//         const tjpAddr = getTjpAddr({ ibGib: timelineV1 });
-
-//         // ensure outer_space is empty // there is no such functionality
-//         // const resGetAddrsOuterBefore = await outer_space.getAddrs({});
-//         // iReckon(sir, 'outer space should be empty initially', resGetAddrsOuterBefore.data.addrs.length, 0);
-
-//         // ACT
-//         // const syncOpts: SyncSpaceOptionsIbGib = {
-//         //     ib: 'sync opts',
-//         //     gib: 'sync_opts_gib',
-//         //     data: {
-//         //         cmdModifiers: ['sync'],
-//         //         ibGibAddrs: timelineAddrs,
-//         //     },
-//         //     ibGibs: timelineIbGibs,
-//         // } as any;
-
-//         // // metaspace.syncIbGibs
-//         // putInSpace({})
-//         // const resSync = await outer_space.put(syncOpts);
-
-//         // ASSERT
-//         // iReckon(sir, `sync result success should be true. res: ${pretty(resSync)}`, resSync.data.success, true);
-//         // iReckon(sir, resSync?.data?.success).asTo(`sync result success`).isGonnaBeTrue();
-
-//         // const resGetAddrsOuterAfter = await outer_space.getAddrs({});
-//         // iReckon(sir, 'outer space should have all timeline ibgibs after sync', resGetAddrsOuterAfter.data.addrs.length, timelineAddrs.length);
-
-//         // const resGetLatest = await outer_space.getLatestAddrs({ data: { ibGibAddrs: [tjpAddr] } } as any);
-//         // const resGetLatest = getLatestAddrs({
-//         //     tjpAddrs: tjpAddrs,
-//         //     space: outer_space,
-//         // });
-//         // iReckon(sir, 'latest addr in outer space should match latest from local', resGetLatest.data.latestAddrsMap[tjpAddr], getIbGibAddr({ ibGib: timelineV2 }));
-//     });
-
-// });
+});

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!;

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

@@ -0,0 +1,90 @@
+/**
+ * @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';
+
+const maam = `[${import.meta.url}]`, sir = maam;
+
+respecfully(sir, `[metaspace-innerspace]`, async () => {
+
+    let metaspace: Metaspace_Innerspace;
+
+    firstOfEach(sir, async () => {
+        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 ifWeMight(sir, `can instantiate`, async () => {
+        iReckon(sir, metaspace).asTo('metaspace').isGonnaBeTruthy();
+        iReckon(sir, metaspace.initialized).asTo('initialized').isGonnaBeTrue();
+    });
+
+    await ifWeMight(sir, `has zeroSpace`, async () => {
+        const zs = metaspace.zeroSpace;
+        iReckon(sir, zs).asTo('zeroSpace').isGonnaBeTruthy();
+    });
+
+    await ifWeMight(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

@@ -2693,11 +2693,49 @@ export async function lockSpace({
                     expirationUTC: getExpirationUTCString({ seconds: secondsValid }),
                 }
             } as IbGibSpaceLockIbGib;
-            const resPut = await putInSpace({ ibGib: resLockIbGib, force: true, space });
-            if (resPut.success) {
-                resLockIbGib.data!.success = true;
+
+            // We must use space.witness (via argy) directly here instead of
+            // `putInSpace` helper, because we need to check
+            // `addrsAlreadyHave`. If the space already has the addr, then
+            // we have lost a race condition and the space is ALREADY locked.
+            const argPut = await space.argy({
+                ibMetadata: getSpaceArgMetadata({ space }),
+                argData: {
+                    cmd: 'put',
+                    force: true,
+                    ibGibAddrs: [spaceLockAddr],
+                },
+                ibGibs: [resLockIbGib],
+            });
+            const resPut = await space.witness(argPut);
+
+            if (resPut.data?.success) {
+                if ((resPut.data.addrsAlreadyHave ?? []).includes(spaceLockAddr)) {
+                    // Race condition lost! The lock was put by someone else in the interim.
+                    if (logalot) { console.log(`${lc} racelost! addrsAlreadyHave includes spaceLockAddr (${spaceLockAddr}) (I: 2e8a1562947c40698110b64251141753)`); }
+
+                    // get the existing lock that beat us
+                    const getLockRace = await getFromSpace({
+                        addr: spaceLockAddr, space, force: true
+                    });
+                    if (getLockRace.success && getLockRace.ibGibs?.length === 1) {
+                        const existingLockRace = getLockRace.ibGibs[0] as IbGibSpaceLockIbGib;
+                        resLockIbGib = clone(existingLockRace) as IbGibSpaceLockIbGib;
+                        resLockIbGib.data!.alreadyLocked = true;
+                        resLockIbGib.data!.success = false;
+                    } else {
+                        // Should be unreachable if addrsAlreadyHave is true, but handle gracefully
+                        const emsg = `${lc} (UNEXPECTED) addrsAlreadyHave true, but couldn't get lock? (E: 8374a2b6628b49369363bc5843105763)`;
+                        console.error(emsg);
+                        resLockIbGib.data!.success = false;
+                        resLockIbGib.data!.errorMsg = emsg;
+                    }
+                } else {
+                    // Success! We put the lock and it was new.
+                    resLockIbGib.data!.success = true;
+                }
             } else {
-                const emsg = `${lc} there was an error putting the lock in the space: ${resPut.errorMsg}`;
+                const emsg = `${lc} there was an error putting the lock in the space: ${resPut.data?.errors?.join('|')}`;
                 resLockIbGib.data!.success = false;
                 resLockIbGib.data!.errorMsg = emsg;
                 console.error(emsg);