@ibgib/core-gib 0.1.29 → 0.1.30

package/src/timeline/timeline-api.mts

@@ -43,16 +43,16 @@ export interface Rel8nRemovalInfo {
 
 export interface CommonTimelineOptsSansSkipLock {
     /**
-     * If true, dna will not be created when executing transforms. 
-     * 
+     * If true, dna will not be created when executing transforms.
+     *
      * ## intent / driving use case
-     * 
-     * We want to use the timeline api in working with the new sync saga code. 
+     *
+     * We want to use the timeline api in working with the new sync saga code.
      * However, we do not want dna, because the sync saga should not be merged
      * and there should be no dynamic composition required from dna.
-     * 
-     * But the default for this api should be for dna to be created, so we add 
-     * this negative flag. 
+     *
+     * But the default for this api should be for dna to be created, so we add
+     * this negative flag.
      */
     noDna?: boolean,
     /**
@@ -173,16 +173,16 @@ export async function appendToTimeline({
     rel8nInfos: Rel8nInfo[],
     /**
      * if provided, will remove this rel8ns before appending {@link rel8nInfos}
-     * 
+     *
      * ## intent/driving use case
-     * 
+     *
      * we need to be able to clear out the existing rel8ns when evolving
      * `SyncSagaIbGib_V1`. This is not quite linkedRel8ns, rather, we just need
      * to clear out the message stones rel8n. The underlying {@link rel8}
      * transform already supports this via this:
-     * 
+     *
      * {@link TransformOpts_Rel8.rel8nsToRemoveByAddr}
-     * 
+     *
      * So these removal infos will translate to those `rel8nsToRemoveByAddr`.
      */
     rel8nRemovalInfos?: Rel8nRemovalInfo[],
@@ -1000,3 +1000,43 @@ export async function getHistory({
         if (logalot) { console.log(`${lc} complete.`); }
     }
 }
+
+export async function getHistoryAddrs({
+    timeline,
+    getLatest,
+    metaspace,
+    space,
+}: {
+    /**
+     * The ibGib at the head of the timeline whose history you want to retrieve.
+     */
+    timeline: IbGib_V1,
+    /**
+     * if true, will first retrieve the latest ibgib in the {@link timeline} in
+     * the given {@link space} if provided, else in the default local user space
+     * according to the {@link metaspace}.
+     */
+    getLatest?: boolean,
+} & CommonTimelineOptsSansSkipLock): Promise<IbGibAddr[]> {
+    const lc = `[${getHistoryAddrs.name}]`;
+    try {
+        if (logalot) { console.log(`${lc} starting... (I: c7a328b14018642138ebb47870c15626)`); }
+
+        const historyInfo = await getHistory({
+            timeline,
+            getLatest,
+            includeDna: false,
+            metaspace,
+            space,
+        });
+
+        const addrs = historyInfo.orderedPastIbGibs.map(x => getIbGibAddr({ ibGib: x }));
+
+        return addrs;
+    } catch (error) {
+        console.error(`${lc} ${extractErrorMsg(error)}`);
+        throw error;
+    } finally {
+        if (logalot) { console.log(`${lc} complete.`); }
+    }
+}

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

@@ -1,6 +1,6 @@
 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 { getIbAndGib, getIbGibAddr, } from '@ibgib/ts-gib/dist/helper.mjs';
 import { validateIbGibIntrinsically } from '@ibgib/ts-gib/dist/V1/validate-helper.mjs';
 
 import { GLOBAL_LOG_A_LOT } from '../../../core-constants.mjs';
@@ -15,6 +15,10 @@ import { ReconciliationSpaceBase, ReconciliationSpaceData, ReconciliationSpaceRe
 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';
+import { isMetaStone, newUpMetaStone, parseMetaStoneIb } from '../../../common/meta-stone/meta-stone-helper.mjs';
+import { MetaStoneIbGib_V1, MetaStoneIbInfo } from '../../../common/meta-stone/meta-stone-types.mjs';
+import { GIB } from '@ibgib/ts-gib/dist/V1/constants.mjs';
+import { META_STONE_TARGET_REL8N_NAME } from '../../../common/meta-stone/meta-stone-constants.mjs';
 
 const logalot = GLOBAL_LOG_A_LOT;
 
@@ -53,6 +57,35 @@ export class InnerSpace_V1<
      */
     ibGibs: { [key: string]: TIbGib } = {};
 
+    /**
+     * Each tjp/timeline has its own map of metastones.
+     *
+     * NOTE: This is a map of maps.
+     */
+    ibGibMetastones: { [tjpOrStoneGib: string]: { [metastoneAddr: string]: MetaStoneIbGib_V1 } } = {};
+    /**
+     * all known metastone addrs for this innerspace
+     */
+    get metastoneAddrs(): IbGibAddr[] {
+        const resMetastones: IbGibAddr[] = [];
+        Object.values(this.ibGibMetastones).forEach(map => {
+            Object.keys(map)
+                .forEach(metastone => resMetastones.push(metastone));
+        });
+        return resMetastones;
+    }
+    /**
+     * all known metastone ibgibs for this innerspace
+     */
+    get metastoneIbGibs(): MetaStoneIbGib_V1[] {
+        const resMetastones: MetaStoneIbGib_V1[] = [];
+        Object.values(this.ibGibMetastones).forEach(map => {
+            Object.values(map)
+                .forEach(metastone => resMetastones.push(metastone));
+        });
+        return resMetastones;
+    }
+
     constructor(
         initialData: TData,
         initialRel8ns?: TRel8ns,
@@ -226,10 +259,30 @@ export class InnerSpace_V1<
             for (let i = 0; i < ibGibs?.length; i++) {
                 const ibGib = ibGibs[i];
                 const addr = getIbGibAddr({ ibGib });
-                if (!Object.keys(this.ibGibs).includes(addr)) {
-                    this.ibGibs[addr] = ibGib;
+
+                if (isMetaStone({ ibGib })) {
+                    const metastone = ibGib as unknown as MetaStoneIbGib_V1;
+                    if (!metastone.data) { throw new Error(`(UNEXPECTED) ibGib is a metastone, but metastone.data falsy? (E: f3a05815c68821d564cb101821b91326)`); }
+                    const { tjpGib } = metastone.data.targetData;
+                    if (this.ibGibMetastones[tjpGib]) {
+                        // has existing metastones for this timeline/stone
+                        if (!Object.keys(this.ibGibMetastones[tjpGib]).includes(addr)) {
+                            this.ibGibMetastones[tjpGib][addr] = metastone;
+                        } else {
+                            addrsAlreadyHave.push(addr);
+                        }
+                    } else {
+                        // no existing metastones for this timeline/stone
+                        this.ibGibMetastones[tjpGib] = {
+                            [addr]: metastone,
+                        };
+                    }
                 } else {
-                    addrsAlreadyHave.push(addr);
+                    if (!Object.keys(this.ibGibs).includes(addr)) {
+                        this.ibGibs[addr] = ibGib;
+                    } else {
+                        addrsAlreadyHave.push(addr);
+                    }
                 }
             }
         } catch (error) {
@@ -301,46 +354,155 @@ export class InnerSpace_V1<
             if (!arg.data) { throw new Error(`(UNEXPECTED) !arg.data? (E: 60869288f3deeff5d1dd93be5f4b8624)`); }
             if (!arg.data.ibGibAddrs) { throw new Error(`(UNEXPECTED) !arg.data.ibGibAddrs? (E: d62cfac462daacc5b2f50c7c3ae45d24)`); }
 
-            // get all ibgibs in the space and group them by their tjp address
-            const ibGibsInSpace = Object.values(this.ibGibs);
-            const ibGibsInSpaceByTjp = groupBy({ items: ibGibsInSpace, keyFn: x => getTjpAddr({ ibGib: x })! });
-
-            if (logalot) { console.log(`${lc} ibGibsInSpaceByTjp: ${pretty(ibGibsInSpaceByTjp)} (I: af9f88985b96822b68ad4928eb6f6a25)`); }
-
             const latestAddrsMap: { [addr: string]: IbGibAddr | null } = {};
 
-            // iterate over each address we're looking for
+            // #region new impl with metastones
+
             for (const localAddr of arg.data.ibGibAddrs) {
+                if (isMetaStone({ addr: localAddr })) {
+                    if (logalot) { console.log(`${lc} localAddr not found: ${localAddr} (I: 12c7668bbdb8e4a86ceb5f455eb00826)`); }
+                    if (this.metastoneAddrs.includes(localAddr)) {
+                        latestAddrsMap[localAddr] = localAddr;
+                    } else {
+                        if (logalot) { console.log(`${lc} metastone addr NOT found...what are we getting latest on metastone anyway? (I: 0e71b8a9234fcc93b8259578eb491626)`); }
+                        latestAddrsMap[localAddr] = null;
+                    }
+                    continue;
+                }
                 const localIbGib = this.ibGibs[localAddr];
                 if (!localIbGib) {
+                    if (logalot) { console.log(`${lc} localAddr not found: ${localAddr} (I: 12c7668bbdb8e4a86ceb5f455eb00826)`); }
                     latestAddrsMap[localAddr] = null; // or handle as error/not found
                     continue;
                 }
 
-                const tjpAddr = getTjpAddr({ ibGib: localIbGib });
-                if (tjpAddr && ibGibsInSpaceByTjp[tjpAddr]) {
-                    // if we have a timeline for this tjp, find the latest
-                    const timeline = ibGibsInSpaceByTjp[tjpAddr];
+                // we have the ibgib, now see if we have any metastones for it.
+                const tjpAddr =
+                    getTjpAddr({ ibGib: localIbGib, defaultIfNone: 'incomingAddr' }) ??
+                    getIbGibAddr({ ibGib: localIbGib });
+                const { gib: tjpGib } = getIbAndGib({ ibGibAddr: tjpAddr });
+                // examine metastones
+                const metastoneMap = this.ibGibMetastones[tjpGib];
+                if (!metastoneMap) {
+                    // no metastones for this, so there is no latest
+                    latestAddrsMap[localAddr] = localAddr;
+                    continue;
+                }
 
-                    if (timeline.some(ibGib => ibGib.data?.n === undefined)) {
-                        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]
+                // we DO have metastone(s) for this timeline/stone, so analyze
+                // these metastones and get the latest according to them
+
+                const metaStoneAddrs = Object.keys(metastoneMap);
+                if (metaStoneAddrs.length === 0) {
+                    throw new Error(`(UNEXPECTED) we have a metastoneMap but no addrs? (E: 82a448407c08585f685a9b2543923826)`);
+                }
 
-                    // last one is the latest
-                    let latestInTimeline = timeline.at(-1);
-                    if (latestInTimeline) {
-                        latestAddrsMap[localAddr] = getIbGibAddr({ ibGib: latestInTimeline });
+                const metaStoneAddrsAndIbInfos: [IbGibAddr, MetaStoneIbInfo][] = metaStoneAddrs
+                    .map(xAddr => [xAddr, getIbAndGib({ ibGibAddr: xAddr }).ib])
+                    .map(([xAddr, metaStoneIb]) => [xAddr, parseMetaStoneIb({ ib: metaStoneIb })]);
+
+                /**
+                 * sort mutates the actual array (shuffle sort I think), but
+                 * we're storing it in a different variable name to be more
+                 * explicit.
+                 */
+                const metaStoneAddrsAndIbInfos_descending = metaStoneAddrsAndIbInfos.sort((a, b) => {
+                    const [_aAddr, aInfo] = a;
+                    const [_bAddr, bInfo] = b;
+                    // we want the highest n, with tiebreaker going to
+                    // timestampInTicks. if that's the same also, then what are we
+                    // quibbling about?
+                    if (aInfo.n > bInfo.n) {
+                        return -1;
+                    } else if (aInfo.n < bInfo.n) {
+                        return 1;
+                    } else if (aInfo.timestampInTicks > bInfo.timestampInTicks) {
+                        return -1;
+                    } else if (aInfo.timestampInTicks < bInfo.timestampInTicks) {
+                        return 1;
                     } else {
-                        latestAddrsMap[localAddr] = null;
+                        // neither discriminator is different.
+                        return 0;
                     }
-                } else {
-                    // if it has no tjp, it is its own latest if it exists
-                    latestAddrsMap[localAddr] = this.ibGibs[localAddr] ? localAddr : null;
+                });
+                if (logalot) {
+                    console.log(`${lc} console.dir(metaStoneAddrsAndIbInfos_descending)... (I: 5ce425f199283e2185a2cc0801264826)`);
+                    console.dir(metaStoneAddrsAndIbInfos_descending);
                 }
+
+                // since we sorted into a descending order, the latest is the very
+                // first item.  and we have already guaranteed that there is at
+                // least 1 in the array.
+                if (metaStoneAddrsAndIbInfos_descending.length === 0) { throw new Error(`(UNEXPECTED) metaStoneAddrsAndIbInfos_descending is empty? earlier in the function there should have been a check. did getMetaStoneAddrs return a populated list but no stones were found? (E: 63c035ebed77741f2330c7a625823f23)`); }
+
+                const [latestMetaStoneAddr, latestMetaStoneInfo] = metaStoneAddrsAndIbInfos_descending[0];
+                if (logalot) { console.log(`${lc} [latestMetaStoneAddr, latestMetaStoneInfo]: ${[latestMetaStoneAddr, latestMetaStoneInfo]}  (I: 1307ca46b4abd62c7a30fe87c08fa923)`); }
+
+                let latestMetaStoneIbGib: MetaStoneIbGib_V1;
+                latestMetaStoneIbGib = metastoneMap[latestMetaStoneAddr];
+
+                // latestMetaStoneIbGib.rel8ns ensured via validation at this point
+                const latestMetaStoneRel8ns = latestMetaStoneIbGib.rel8ns!;
+                /**
+                 * this is accurate as the punctiliar address that corresponds to
+                 * the metastone.
+                 *
+                 * atow (11/2023) interface of rel8ns
+                 * [META_STONE_TARGET_REL8N_NAME]: IbGibAddr[];
+                 * [META_STONE_TARGET_TJP_REL8N_NAME]?: IbGibAddr[];
+                 */
+                const latestAddr = latestMetaStoneRel8ns[META_STONE_TARGET_REL8N_NAME].at(0);
+                if (!latestAddr) { throw new Error(`metastone passed validation but latestMetaStoneRel8ns[META_STONE_TARGET_REL8N_NAME].at(0) is empty? (E: c188ec0089ad86efe4d925c118599d23)`); }
+
+                latestAddrsMap[localAddr] = latestAddr;
             }
+            // #region new impl with metastones
+
+
+            // #region old inefficient no metastones
+
+            // // wildly inefficient with a decent number of ibgibs
+            // // get all ibgibs in the space and group them by their tjp address
+            // const ibGibsInSpace = Object.values(this.ibGibs);
+            // const ibGibsInSpaceByTjp = groupBy({ items: ibGibsInSpace, keyFn: x => getTjpAddr({ ibGib: x })! });
+
+            // if (logalot) { console.log(`${lc} ibGibsInSpaceByTjp: ${pretty(ibGibsInSpaceByTjp)} (I: af9f88985b96822b68ad4928eb6f6a25)`); }
+
+
+            // // iterate over each address we're looking for
+            // for (const localAddr of arg.data.ibGibAddrs) {
+            //     const localIbGib = this.ibGibs[localAddr];
+            //     if (!localIbGib) {
+            //         latestAddrsMap[localAddr] = null; // or handle as error/not found
+            //         continue;
+            //     }
+
+            //     const tjpAddr = getTjpAddr({ ibGib: localIbGib });
+            //     if (tjpAddr && ibGibsInSpaceByTjp[tjpAddr]) {
+            //         // if we have a timeline for this tjp, find the latest
+            //         const timeline = ibGibsInSpaceByTjp[tjpAddr];
+
+            //         if (timeline.some(ibGib => ibGib.data?.n === undefined)) {
+            //             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]
+
+            //         // last one is the latest
+            //         let latestInTimeline = timeline.at(-1);
+            //         if (latestInTimeline) {
+            //             latestAddrsMap[localAddr] = getIbGibAddr({ ibGib: latestInTimeline });
+            //         } else {
+            //             latestAddrsMap[localAddr] = null;
+            //         }
+            //     } else {
+            //         // if it has no tjp, it is its own latest if it exists
+            //         latestAddrsMap[localAddr] = this.ibGibs[localAddr] ? localAddr : null;
+            //     }
+            // }
+
+            // #endregion old inefficient no metastones
 
             resultData.latestAddrsMap = latestAddrsMap;
             resultData.success = true;

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

@@ -201,4 +201,17 @@ await respecfully(sir, `[${InnerSpace_V1.name} specs]`, async () => {
 
     });
 
+    // await respecfully(sir, 'latest and metastone related', async () => {
+
+    // with the current innerspace implementation (01/26/2026), I am getting
+    // "latest already exist" warnings when calls to registerNewIbGib are
+    // called.  this is because the initial implementation always gets the
+    // latest by brute forcing splitting ALL in-memory ibgibs by timelines,
+    // which is ridiculously inefficient. So I am adding metastone indexing
+    // to the innerspace.
+
+    //
+
+    // });
+
 });

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

@@ -979,7 +979,8 @@ export async function registerNewIbGib({
                         } else {
                             // not newer
                             if (logalot) { console.log(`is not newer, so we don't need to do anything else. (I: 14c25dc3314748dc909d61b77eb64354)`) }
-                            console.warn(`${lc} incoming ibGib (${ibGibAddr}) has the same data.n value as another ibgib (${existingLatestAddr}), but different addresses. multiple branches for the same timeline? ignoring incoming ibGibAddr (W: 057baadca494473dabb26fb4fb879774)`)
+                            debugger; // temp remove this...
+                            console.warn(`${lc} incoming ibGib (${ibGibAddr}) is NOT NEWER than existing latest (${existingLatestAddr}). multiple branches for the same timeline? ignoring incoming ibGibAddr. n_ibGib: ${n_ibGib}. n_existingLatest: ${n_existingLatest}. space.ib: ${space.ib} (W: 057baadca494473dabb26fb4fb879774)`)
                             return; /* <<<< returns early */
                         }
                     } else {
@@ -3434,7 +3435,7 @@ export function spaceNameIsValid(name: string): boolean {
 
 /**
  * wrapper for getting dependency graph from a space.
- * 
+ *
  * NOTE: This calls the witness space with the command. This is NOT the
  * same as the logic helper in graph-helper.mts which performs the graph
  * traversal logic potentially in-memory or naively.