@ibgib/core-gib 0.0.112 → 0.1.1

package/src/timeline/timeline-types.mts

@@ -0,0 +1,38 @@
+import { IbGibAddr } from "@ibgib/ts-gib/dist/types.mjs";
+import { IbGib_V1 } from "@ibgib/ts-gib/dist/V1/types.mjs";
+
+/**
+ * A history information record that gives access to a given timeline.
+ *
+ * ## NOTE on timeline, "latest", out-of-date, etc.
+ *
+ * Unless the timeline is locked, this timeline info could be out-of-date at any
+ * moment.
+ *
+ * If this timeline info was built using the latest ibgib in a given space, then
+ * this will be current (not out-of-date). The {@link headIbGib} will be the latest ibgib
+ * in the timeline, and it the past will be complete.
+ *
+ * If the timeline was not built using the latest ibgib in the space, then this
+ * timeline info will be built according to the ibgib it was given at the time
+ * and will be correct relative to that ibgib as the {@link headIbGib}.
+ */
+export interface TimelineHistoryInfo {
+    /**
+     * The "latest" ibgib in the given timeline, BUT ONLY PER CONTEXT.
+     */
+    headIbGib: IbGib_V1;
+    /**
+     * Fully loaded ibGibs for a timeline.
+     */
+    orderedPastIbGibs: IbGib_V1[];
+    /**
+     * Same as {@link orderedPastIbGibs}, but mapped out by their ibGibAddr -> ibGib.
+     */
+    pastIbGibMap: { [addr: IbGibAddr]: IbGib_V1 };
+    /**
+     * If provided, this is a map of a dnaIbGibAddr -> dnaIbGib. This is to be
+     * used in combination with a given ibGib.rel8ns.dna addrs.
+     */
+    dnaMap?: { [addr: IbGibAddr]: IbGib_V1 };
+}

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

@@ -1603,7 +1603,4 @@ export abstract class FilesystemSpace_V1<
     }
 
     // #endregion other helpers
-
-    private foo(): void {
-    }
 }

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

@@ -0,0 +1 @@
+export const DEFAULT_INNER_SPACE_DESCRIPTION = `This is an in-memory innerspace.`;

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

@@ -0,0 +1,44 @@
+import { ReconciliationSpaceData, ReconciliationSpaceRel8ns } from "../reconciliation-space/reconciliation-space-base.mjs";
+import { DEFAULT_LOCAL_SPACE_POLLING_INTERVAL_MS, IBGIB_SPACE_NAME_DEFAULT, ZERO_SPACE_ID } from "../space-constants.mjs";
+import { DEFAULT_INNER_SPACE_DESCRIPTION } from "./inner-space-constants.mjs";
+
+export interface InnerSpaceData_V1 extends ReconciliationSpaceData {
+    // /**
+    //  * If true, then this will include this space's ibGib's addrs (i.e. index)
+    //  * in its {@link data} property.
+    //  */
+    // trackAddrs: boolean;
+}
+
+/**
+ * Used in bootstrapping.
+ *
+ * If you change this, please bump the version
+ *
+ * (but of course won't be the end of the world when this doesn't happen).
+ *
+ * ## notes
+ *
+ * This is a terrible kluge port from NodeFilesystemSpaceData_V1. I am just
+ * moving "as fast as I can" (I can't move fast these days). Little of the
+ * filesystem internal details reallly matter I think, as this is just meant to
+ * be a local space living on indexeddb. The main thing is segregation of local
+ * spaces from each other, but I think this is covered to begin with via the
+ * space name used in the path somewhere.
+ */
+export const DEFAULT_INNER_SPACE_DATA_V1: InnerSpaceData_V1 = {
+    version: '1',
+    uuid: ZERO_SPACE_ID,
+    name: IBGIB_SPACE_NAME_DEFAULT,
+    classname: 'InnerSpace_V1',
+    persistOptsAndResultIbGibs: false,
+    validateIbGibAddrsMatchIbGibs: false,
+    longPollingIntervalMs: DEFAULT_LOCAL_SPACE_POLLING_INTERVAL_MS,
+    allowPrimitiveArgs: false,
+    catchAllErrors: true,
+    description: DEFAULT_INNER_SPACE_DESCRIPTION,
+    trace: false,
+}
+
+export interface InnerSpaceRel8ns_V1 extends ReconciliationSpaceRel8ns {
+}

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

@@ -1,31 +1,22 @@
+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, IbGibRel8ns_V1, IbGibData_V1, sha256v1, Factory_V1, ROOT, getGib,
-} from '@ibgib/ts-gib/dist/V1/index.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 { SpaceBase_V1 } from '../space-base-v1.mjs';
+import { GLOBAL_LOG_A_LOT } from '../../../core-constants.mjs';
 import {
     IbGibSpaceData, IbGibSpaceOptionsData, IbGibSpaceOptionsRel8ns,
     IbGibSpaceOptionsIbGib, IbGibSpaceResultData, IbGibSpaceResultRel8ns,
-    IbGibSpaceResultIbGib,
-    IbGibSpaceRel8ns
+    IbGibSpaceResultIbGib, IbGibSpaceRel8ns,
 } from '../space-types.mjs';
-import { getSpaceIb } from '../space-helper.mjs';
-import { GLOBAL_LOG_A_LOT } from '../../../core-constants.mjs';
+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';
 
 const logalot = GLOBAL_LOG_A_LOT;
 
-export interface InnerSpace_V1_Data extends IbGibSpaceData {
-    // /**
-    //  * If true, then this will include this space's ibGib's addrs (i.e. index)
-    //  * in its {@link data} property.
-    //  */
-    // trackAddrs: boolean;
-}
-export interface InnerSpace_V1_Rel8ns extends IbGibSpaceRel8ns {
-}
 
 /**
  * Base class convenience for a "local" space
@@ -36,19 +27,18 @@ export interface InnerSpace_V1_Rel8ns extends IbGibSpaceRel8ns {
  */
 export class InnerSpace_V1<
     TIbGib extends IbGib_V1 = IbGib_V1,
-    TData extends InnerSpace_V1_Data = InnerSpace_V1_Data,
-    TRel8ns extends InnerSpace_V1_Rel8ns = InnerSpace_V1_Rel8ns
-> extends SpaceBase_V1<
+    TData extends InnerSpaceData_V1 = InnerSpaceData_V1,
+    TRel8ns extends InnerSpaceRel8ns_V1 = InnerSpaceRel8ns_V1
+> extends ReconciliationSpaceBase<
     TIbGib,
+    TData,
+    TRel8ns,
     IbGibSpaceOptionsData,
     IbGibSpaceOptionsRel8ns,
     IbGibSpaceOptionsIbGib<TIbGib, IbGibSpaceOptionsData, IbGibSpaceOptionsRel8ns>,
     IbGibSpaceResultData,
     IbGibSpaceResultRel8ns,
-    IbGibSpaceResultIbGib<TIbGib, IbGibSpaceResultData, IbGibSpaceResultRel8ns>,
-    TData,
-    TRel8ns
-> {
+    IbGibSpaceResultIbGib<TIbGib, IbGibSpaceResultData, IbGibSpaceResultRel8ns>> {
 
     /**
      * Log context for convenience with logging. (Ignore if you don't want to use this.)
@@ -75,11 +65,28 @@ export class InnerSpace_V1<
     protected async initialize(): Promise<void> {
         const lc = `${this.lc}[${this.initialize.name}]`;
         try {
+            // if (logalot) { console.log(`${lc} starting...`); }
+            // await super.initialize();
+            // if (!this.data) { throw new Error(`(UNEXPECTED) this.data is falsy? (E: 6461b2e4c9877053689dbc8bb375a623)`); }
+            // if (!this.data?.classname) { this.data!.classname = InnerSpace_V1.name }
+            // this.ib = getSpaceIb({ space: this });
+            // this.gib = await getGib({ ibGib: this });
+
             if (logalot) { console.log(`${lc} starting...`); }
-            await super.initialize();
-            if (!this.data) { throw new Error(`(UNEXPECTED) this.data is falsy? (E: 6461b2e4c9877053689dbc8bb375a623)`); }
-            if (!this.data?.classname) { this.data!.classname = InnerSpace_V1.name }
-            this.ib = getSpaceIb({ space: this });
+            if (!this.data) {
+                this.data = clone(DEFAULT_INNER_SPACE_DATA_V1);
+                this.data = this.data!; // why does ts compiler need this?
+            }
+            if (this.data!.classname !== InnerSpace_V1.name) {
+                if (this.data.classname) {
+                    // only warn if the consumer has explicitly set a different classname
+                    console.warn(`${lc} this.data.classname (${this.data.classname}) !== ${InnerSpace_V1.name}. overriding this. (W: 4cac18140e58f0bd2890010a3639d225)`);
+                }
+                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)`); }
+
+            this.ib = getSpaceIb({ space: this, classname: this.data!.classname });
             this.gib = await getGib({ ibGib: this });
         } catch (error) {
             console.error(`${lc} ${error.message}`);
@@ -89,6 +96,61 @@ export class InnerSpace_V1<
         }
     }
 
+    protected async _getLatestAddrsInStore(ibGibs: TIbGib[]): Promise<{ [addr: string]: IbGibAddr | null; }> {
+        const lc = `${this.lc}[_getLatestAddrsInStore]`;
+        try {
+            if (logalot) { console.log(`${lc} starting...`); }
+            const ibGibAddrs = ibGibs.map(x => getIbGibAddr({ ibGib: x }));
+            const arg = { data: { ibGibAddrs } } as IbGibSpaceOptionsIbGib;
+            const resGet = await this.getLatestAddrsImpl(arg as any);
+            return resGet.data!.latestAddrsMap!;
+        } catch (error) {
+            console.error(`${lc} ${extractErrorMsg(error)}`);
+            throw error;
+        }
+    }
+
+    protected async _getIbGibsFromStore(addrs: IbGibAddr[]): Promise<{ [addr: string]: TIbGib; }> {
+        const lc = `${this.lc}[_getIbGibsFromStore]`;
+        try {
+            if (logalot) { console.log(`${lc} starting...`); }
+            const res: { [addr: string]: TIbGib } = {};
+            for (const addr of addrs) {
+                if (this.ibGibs[addr]) {
+                    res[addr] = this.ibGibs[addr];
+                }
+            }
+            return res;
+        } catch (error) {
+            console.error(`${lc} ${extractErrorMsg(error)}`);
+            throw error;
+        }
+    }
+
+    protected async _putIbGibsToStore(ibGibs: TIbGib[]): Promise<void> {
+        const lc = `${this.lc}[_putIbGibsToStore]`;
+        try {
+            if (logalot) { console.log(`${lc} starting...`); }
+            await this.putIbGibsImpl({ ibGibs, addrsAlreadyHave: [] });
+        } catch (error) {
+            console.error(`${lc} ${extractErrorMsg(error)}`);
+            throw error;
+        }
+    }
+
+    protected async _deleteIbGibsFromStore(addrs: IbGibAddr[]): Promise<void> {
+        const lc = `${this.lc}[_deleteIbGibsFromStore]`;
+        try {
+            if (logalot) { console.log(`${lc} starting...`); }
+            for (const addr of addrs) {
+                delete this.ibGibs[addr];
+            }
+        } catch (error) {
+            console.error(`${lc} ${extractErrorMsg(error)}`);
+            throw error;
+        }
+    }
+
     protected async getImpl(arg: IbGibSpaceOptionsIbGib<TIbGib, IbGibSpaceOptionsData, IbGibSpaceOptionsRel8ns>):
         Promise<IbGibSpaceResultIbGib<TIbGib, IbGibSpaceResultData, IbGibSpaceResultRel8ns>> {
         const lc = `${this.lc}[${this.getImpl.name}]`;
@@ -229,6 +291,73 @@ export class InnerSpace_V1<
         const result = await this.resulty({ resultData });
         return result;
     }
+    protected async getLatestAddrsImpl(arg: IbGibSpaceOptionsIbGib<TIbGib, IbGibSpaceOptionsData, IbGibSpaceOptionsRel8ns>): Promise<IbGibSpaceResultIbGib<TIbGib, IbGibSpaceResultData, IbGibSpaceResultRel8ns>> {
+        const lc = `${this.lc}[${this.getLatestAddrsImpl.name}]`;
+        if (logalot) { console.log(`${lc} starting... (I: 913548fe045270432ea96f2a59ca6625)`); }
+        const resultData: IbGibSpaceResultData = { optsAddr: getIbGibAddr({ ibGib: arg }), }
+        try {
+            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
+            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)) {
+                        console.warn(`${lc} timeline includes ibgibs with ibGib.data?.n === undefined (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;
+                }
+            }
+
+            resultData.latestAddrsMap = latestAddrsMap;
+            resultData.success = true;
+
+        } catch (error) {
+            const emsg = `${lc} ${extractErrorMsg(error)}`;
+            console.error(emsg);
+            resultData.errors = [emsg];
+        }
+
+        try {
+            let result = await this.resulty({ resultData });
+            return result;
+        } catch (error) {
+            console.error(`${lc}[resulty] ${extractErrorMsg(error)}`);
+            throw error;
+        } finally {
+            if (logalot) { console.log(`${lc} complete. (I: 913548fe045270432ea96f2a59ca6625)`); }
+        }
+    }
     /**
      * Performs a naive `exists: boolean` or `includes: boolean` analog.
      *

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

@@ -1,69 +1,253 @@
-import { getUUID, } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+import { extractErrorMsg, getUUID, pretty, } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
 import {
-    firstOfEach, firstOfAll, ifWe,
-    lastOfEach, lastOfAll,
-    ifWeMight, iReckon, respecfully
+    ifWe, ifWeMight, iReckon,
+    respecfully, respecfullyDear,
 } 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 { getTjpAddr } from '../../../common/other/ibgib-helper.mjs';
+// import { SyncSpaceOptionsIbGib } from '../outer-space/outer-space-types.mjs';
 
 import {
     testSpace_createAndInit,
     testSpace_persistTransformResult,
-    testSpace_putGetDelete
+    testSpace_putGetDelete,
+    testSpace_registerNewIbGib_GetLatest,
 } from '../space-respec-helper.mjs';
-import { InnerSpace_V1, } from './inner-space-v1.mjs';
-
-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));
-        },
-    });
+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';
 
-    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));
-        },
-    });
+// ifWeMight() // don't remove this line while we're actively testing on this file. it is a limitation of my shortcut discovery script that it looks for a regex that matches ifWeMight/respecfullyDear followed by an open paren
+
+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 })
+                }
+            },
+        });
+        return metaspace;
+    } catch (error) {
+        console.error(`${lc} ${extractErrorMsg(error)}`);
+        throw error;
+    } finally {
+        if (logalot) { console.log(`${lc} complete.`); }
+    }
+}
+
+await respecfullyDear(sir, 'metaspace setup itself', async () => {
+    await ifWeMight(sir, 'should init a metaspace', async () => {
+        const testSpaceName = 'TestSpaceName';
+
+        const metaspace = await getNewInitializedInMemoryMetaspaceForTesting({
+            defaultSpaceName: testSpaceName
+        });
 
+        iReckon(sir, metaspace.zeroSpace).asTo('metaspace should have a zero space').isGonnaBeTruthy();
+    });
 });
+
+// await respecfullyDear(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

@@ -3496,7 +3496,13 @@ export abstract class MetaspaceBase implements MetaspaceService {
         try {
             if (logalot) { console.log(`${lc} starting...`); }
             const autosyncsIbGib = await this.getSpecialIbGib({ type: "autosyncs" });
-            if (!autosyncsIbGib?.rel8ns) { throw new Error(`autosyncsIbGib?.rel8ns falsy (E: 3fdcdf40f33c41ed9b7a01a079a8fd71)`); }
+            if (!autosyncsIbGib) {
+                console.warn(`${lc} autosyncsIbGib ("autosyncs") special ibgib not found not found. maybe fine, no idea. (W: 30ad2df15b38999106883358722fd425)`);
+                return; /* <<<< returns early */
+            }
+
+            // if (!autosyncsIbGib?.rel8ns) { throw new Error(`autosyncsIbGib?.rel8ns falsy (E: 3fdcdf40f33c41ed9b7a01a079a8fd71)`); }
+
             if (autosyncsIbGib.rel8ns) {
                 this._alwaysAutosyncTjpAddrsCache =
                     new Set(autosyncsIbGib.rel8ns[AUTOSYNC_ALWAYS_REL8N_NAME]);