@ibgib/core-gib 0.1.11 → 0.1.13

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 { clone, extractErrorMsg, getUUID, 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;
 
@@ -84,7 +85,8 @@ export class InnerSpace_V1<
                 }
                 this.data!.classname = InnerSpace_V1.name; // always set?
             }
-            if (!this.data.uuid) { throw new Error(`this.data.uuid is falsy. right now i'm assuming data.uuid is truthy. this is what i'm using atow (12/2024) (E: e531e3c812c22324e856cf219e337825)`); }
+            // if (!this.data.uuid) { throw new Error(`this.data.uuid is falsy. right now i'm assuming data.uuid is truthy. this is what i'm using atow (12/2024) (E: e531e3c812c22324e856cf219e337825)`); }
+            this.data.uuid ??= await getUUID();
 
             this.ib = getSpaceIb({ space: this, classname: this.data!.classname });
             this.gib = await getGib({ ibGib: this });
@@ -197,7 +199,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 +323,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.