@ibgib/core-gib 0.0.64 → 0.0.66

package/src/witness/space/metaspace/metaspace-base.mts

@@ -1,5 +1,6 @@
 import { delay, getUUID, groupBy, pretty } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
 import { encrypt, decrypt, } from '@ibgib/encrypt-gib/dist/encrypt-decrypt.mjs';
+import { DEFAULT_ALPHABET_INDEXING_MODE_BLOCKMODE, DEFAULT_ALPHABET_INDEXING_MODE_LEGACY } from '@ibgib/encrypt-gib/dist/constants.mjs';
 import { IbGib_V1, } from '@ibgib/ts-gib/dist/V1/types.mjs';
 import { GIB, GIB_DELIMITER, IB, ROOT, } from '@ibgib/ts-gib/dist/V1/constants.mjs';
 import { IbGibAddr, TjpIbGibAddr, TransformResult, } from '@ibgib/ts-gib/dist/types.mjs';
@@ -14,7 +15,8 @@ import {
 } from '../../../common/other/other-types.mjs';
 import { TagIbGib_V1 } from '../../../common/tag/tag-types.mjs';
 import {
-    ParticipantInfo, StatusCode, SyncSagaInfo, SyncSpaceOptionsData,
+    OuterSpaceData,
+    ParticipantInfo, StatusCode, SyncSagaInfo, SyncSpaceIbGib, SyncSpaceOptionsData,
     SyncSpaceOptionsIbGib, SyncSpaceResultIbGib, SyncStatusIbGib,
 } from '../../../witness/space/outer-space/outer-space-types.mjs';
 import { IbGibSpaceData, IbGibSpaceRel8ns, SpaceId } from '../../../witness/space/space-types.mjs';
@@ -49,7 +51,7 @@ import { spaceNameIsValid, } from '../../../witness/space/space-helper.mjs';
 import { RobbotPromptResult } from '../../../witness/robbot/robbot-types.mjs';
 import { createNewRobbot, validateCommonRobbotData, validateCommonRobbotIbGib } from '../../../witness/robbot/robbot-helper.mjs';
 import { AppPromptResult } from '../../../witness/app/app-types.mjs';
-import { createNewApp, documentLocationIsAtWelcomePage } from '../../../witness/app/app-helper.mjs';
+import { createNewApp, } from '../../../witness/app/app-helper.mjs';
 import { CommentIbGib_V1, UpdateCommentPromptResult } from '../../../common/comment/comment-types.mjs';
 import { IbGibCacheService } from '../../../common/cache/cache-types.mjs';
 import { BOOTSTRAP_DATA_KNOWN_SPACE_IDS_KEY, BOOTSTRAP_IBGIB_ADDR } from '../../../witness/space/bootstrap/bootstrap-constants.mjs';
@@ -1879,19 +1881,19 @@ export abstract class MetaspaceBase implements MetaspaceService {
         const lc = `${this.lc}[${this.getPlaintextString.name}]`;
         try {
             // validate
-            if ((secretIbGibs || []).length === 0) { throw new Error(`secretIbGibs required.`); }
+            if ((secretIbGibs || []).length === 0) { throw new Error(`secretIbGibs required. (E: 99a605b540c54b6db4d2ffe2caeb226a)`); }
             if (!ciphertextIbGib.data) { throw new Error(`ciphertextIbGib.data falsy (E: 598fc6473149e240a7d6916ecf642323)`); }
             if (!ciphertextIbGib.data.ciphertext) { throw new Error(`ciphertextIbGib.data.ciphertext falsy (E: 0e764a71ec214132a5a528f17f495a7c)`); }
-            if (!ciphertextIbGib.rel8ns?.encryption) { throw new Error(`ciphertextIbGib.rel8ns.encryption falsy`) }
-            if (ciphertextIbGib.rel8ns!.encryption!.length !== 1) { throw new Error(`ciphertextIbGib.rel8ns!.encryption!.length !== 1`); }
+            if (!ciphertextIbGib.rel8ns?.encryption) { throw new Error(`ciphertextIbGib.rel8ns.encryption falsy (E: a0b4d5d8674b4d0191fa619164153022)`) }
+            if (ciphertextIbGib.rel8ns!.encryption!.length !== 1) { throw new Error(`ciphertextIbGib.rel8ns!.encryption!.length !== 1 (E: a4a463e1ef0e45b4917eb04cb40d8173)`); }
 
             // get corresponding encryption ibgib for encryption settings
             const encryptionAddr = ciphertextIbGib.rel8ns!.encryption![0];
             const resEncryption = await this.get({ addr: encryptionAddr, space });
-            if (!resEncryption.success) { throw new Error(`get encryption failed`); }
-            if ((resEncryption.ibGibs || []).length !== 1) { throw new Error(`get encryption retrieved non-1 length (eesh)`); }
+            if (!resEncryption.success) { throw new Error(`get encryption failed (E: feef34c05fae439c81ade7fc23037af1)`); }
+            if ((resEncryption.ibGibs || []).length !== 1) { throw new Error(`get encryption retrieved non-1 length (eesh) (E: 5d7e2023cc2b4e349574c17d5cfc8867)`); }
             const encryptionIbGib = resEncryption.ibGibs![0] as IbGib_V1<EncryptionData_V1>;
-            if (!encryptionIbGib.data) { throw new Error('encryptionIbGib.data falsy'); }
+            if (!encryptionIbGib.data) { throw new Error(`encryptionIbGib.data falsy (E: 409a243afbf24c20987524f6588816fa)`); }
 
             // prompt user for the password
             const password = await this.getPasswordForSecrets({
@@ -1904,13 +1906,23 @@ export abstract class MetaspaceBase implements MetaspaceService {
 
             // we're about the decrypt, but maybe the data doesn't have everything.
             // So WARN for any defaults we're using.
-            if (!encryptionIbGib.data.initialRecursions) { console.warn(`${lc} using default initialRecursions`); }
-            if (!encryptionIbGib.data.recursionsPerHash) { console.warn(`${lc} using default recursionsPerHash`); }
-            if (!encryptionIbGib.data.saltStrategy) { console.warn(`${lc} using default saltStrategy`); }
-            if (!encryptionIbGib.data.hashAlgorithm) { console.warn(`${lc} using default hashAlgorithm`); }
+            if (!encryptionIbGib.data.initialRecursions) { console.warn(`${lc} using default initialRecursions because encryptionIbGib does not state this explicitly (W: 66774cbfccd44423949d34167da6d50b)`); }
+            if (!encryptionIbGib.data.recursionsPerHash) { console.warn(`${lc} using default recursionsPerHash because encryptionIbGib does not state this explicitly (W: 29e264094f384d259319ba8587cd4f63)`); }
+            if (!encryptionIbGib.data.saltStrategy) { console.warn(`${lc} using default saltStrategy because encryptionIbGib does not state this explicitly (W: 7a5acadb8d634c7e87f62c86b57ac7a2)`); }
+            if (!encryptionIbGib.data.hashAlgorithm) { console.warn(`${lc} using default hashAlgorithm because encryptionIbGib does not state this explicitly(W: 2254db3569534b239a8c471b700c8500)`); }
+
+            const defaultIndexingMode = encryptionIbGib.data.blockMode ?
+                DEFAULT_ALPHABET_INDEXING_MODE_BLOCKMODE :
+                DEFAULT_ALPHABET_INDEXING_MODE_LEGACY;
+            if (encryptionIbGib.data.blockMode) {
+                if (!encryptionIbGib.data.blockModeOptions) { throw new Error(`invalid encryptionIbGib.data. blockMode is truthy but blockModeOptions is falsy. (E: 84bbc27a5248b7c4734a1674e41dd224)`); }
+                if (!encryptionIbGib.data.indexingMode) {
+                    console.warn(`${lc} not complete. using default indexingMode ${defaultIndexingMode} because encryptionIbGib does not state this explicitly. (W: c15797cd8d0740ea886a348c10be2e5c)`)
+                }
+            }
 
             // do actual decryption
-            if (logalot) { console.log(`${lc} starting decrypt...`); }
+            if (logalot) { console.log(`${lc} starting decrypt... (I: e14176ebc9a7470fb977d2184f1e2430)`); }
             const timerName = 'sync_log decrypt';
             console.time(timerName);
             console.timeLog(timerName, 'decrypting...');
@@ -1927,10 +1939,12 @@ export abstract class MetaspaceBase implements MetaspaceService {
                 hashAlgorithm:
                     encryptionIbGib.data.hashAlgorithm || DEFAULT_ENCRYPTION_HASH_ALGORITHM,
                 encryptedDataDelimiter: encryptionIbGib.data.encryptedDataDelimiter,
+                blockMode: encryptionIbGib.data.blockMode ? encryptionIbGib.data.blockModeOptions! : undefined,
+                indexingMode: encryptionIbGib.data.indexingMode || defaultIndexingMode,
             });
             console.timeLog(timerName, 'decrypting complete.');
             console.timeEnd(timerName);
-            if (logalot) { console.log(`${lc} decrypt complete.`); }
+            if (logalot) { console.log(`${lc} decrypt complete. (I: 15a8182230294a8a96504ba3667f039a)`); }
             if (resDecrypt.errors?.length ?? 0 > 0) { throw new Error(resDecrypt.errors!.join('|')); }
 
             if (!resDecrypt.decryptedData) { throw new Error(`(UNEXPECTED) resDecrypt has no errors but resDecrypt.decryptedData falsy? (E: 06e73992fb02e45e3c18db33f9a61b23)`); }
@@ -1943,76 +1957,76 @@ export abstract class MetaspaceBase implements MetaspaceService {
         }
     }
 
-    async unwrapEncryptedSyncSpace({
-        encryptedSpace,
-        fnPromptPassword,
-        dontPrompt,
-        space,
-        fnSpaceFactory,
-    }: {
-        encryptedSpace: IbGibSpaceAny,
-        fnPromptPassword: (title: string, msg: string) => Promise<string | null>,
-        dontPrompt?: boolean,
-        space?: IbGibSpaceAny,
-        fnSpaceFactory: (unencryptedSpaceData: any) => Promise<IbGibSpaceAny>,
-    }): Promise<IbGibSpaceAny> {
-        const lc = `${this.lc}[${this.unwrapEncryptedSyncSpace.name}]`;
-        try {
-            // validation
-            if (!space) { throw new Error(`space required (E: d4d3eaa2d7b9143cf1173b8ae6344c23)`); }
-            if (!encryptedSpace.rel8ns?.ciphertext) { throw new Error(`encryptedSpace is not a ciphertext`); }
-            if (encryptedSpace.rel8ns!.ciphertext!.length !== 1) { throw new Error(`only 1 ciphertext rel8n allowed...`); }
-
-            // get ciphertext ibgib
-            const ciphertextAddr = encryptedSpace.rel8ns!.ciphertext![0];
-            const resCiphertext = await this.get({ addr: ciphertextAddr, space });
-            if (!resCiphertext.success) { throw new Error(`get ciphertext failed`); }
-            if ((resCiphertext.ibGibs || []).length !== 1) { throw new Error(`get ciphertext retrieved non-1 length (eesh)`); }
-            const ciphertextIbGib = resCiphertext.ibGibs![0] as CiphertextIbGib_V1;
-
-            // get secrets associated with enciphered space
-            if (!encryptedSpace.rel8ns?.secret) { throw new Error('!encryptionIbGib.rel8ns?.secret'); }
-            const secretAddrs = encryptedSpace.rel8ns!.secret!;
-            const localUserSpace = await this.getLocalUserSpace({});
-            if (!localUserSpace) { throw new Error(`(UNEXPECTED) could not get localUserSpace? (E: 3c5687a15b3b58e3dcf1eca4f5fe5723)`); }
-            const argGetSecrets = await localUserSpace.argy({
-                argData: { ibGibAddrs: secretAddrs, cmd: 'get', }
-            });
-            const resSecrets = await localUserSpace.witness(argGetSecrets);
-            if (!resSecrets.data?.success || (resSecrets.ibGibs || []).length === 0) {
-                throw new Error(`couldn't get secret ibgibs`);
-            }
-            const secretIbGibs = resSecrets.ibGibs.concat() as IbGib_V1<SecretData_V1>[];
-
-            // get plaintext now that we have the ciphertext ibgib and secret ibgib(s)
-            const plaintextString = await this.getPlaintextString({
-                ciphertextIbGib: ciphertextIbGib,
-                fnPromptPassword,
-                dontPrompt,
-                secretIbGibs,
-                space,
-            });
-
-            const syncSpaceData = JSON.parse(plaintextString);
-            if (syncSpaceData.type !== 'sync') { throw new Error(`syncSpaceData.type !== 'sync'...this is the only one implemented right now`); }
-            if (syncSpaceData.subtype !== 'aws-dynamodb') { throw new Error(`syncSpaceData.subtype !== 'aws-dynamodb'...only one right now dude`); }
-
-            // this is the original aws only implementation. I've just added (untested)
-            // a quick factory function where the consumer would do the following code.
-            const unwrappedSpace = await fnSpaceFactory(syncSpaceData);
-            return unwrappedSpace;
-            // so we have a syncspace data (only aws-dynamodb space right now).
-            // load this data into a space class with behavior (not just the dto).
-            // const awsSpace = new AWSDynamoSpace_V1(syncSpaceData, null);
-            // awsSpace.gib = await getGib({ ibGib: awsSpace, hasTjp: false });
-            // if (logalot) { console.log(`awsSpace.gib: ${awsSpace.gib}`); }
-            // return awsSpace;
-
-        } catch (error) {
-            console.error(`${lc} ${error.message}`);
-            throw error;
-        }
-    }
+    // async unwrapEncryptedSyncSpace({
+    //     encryptedSpace,
+    //     fnPromptPassword,
+    //     dontPrompt,
+    //     space,
+    //     fnSpaceFactory,
+    // }: {
+    //     encryptedSpace: IbGibSpaceAny,
+    //     fnPromptPassword: (title: string, msg: string) => Promise<string | null>,
+    //     dontPrompt?: boolean,
+    //     space?: IbGibSpaceAny,
+    //     fnSpaceFactory: (syncSpaceIbGib: SyncSpaceIbGib) => Promise<IbGibSpaceAny>,
+    // }): Promise<IbGibSpaceAny> {
+    //     const lc = `${this.lc}[${this.unwrapEncryptedSyncSpace.name}]`;
+    //     try {
+    //         // validation
+    //         if (!space) { throw new Error(`space required (E: d4d3eaa2d7b9143cf1173b8ae6344c23)`); }
+    //         if (!encryptedSpace.rel8ns?.ciphertext) { throw new Error(`encryptedSpace is not a ciphertext (E: be5504a5e2b84f3eaa8fbd6e13aab659)`); }
+    //         if (encryptedSpace.rel8ns!.ciphertext!.length !== 1) { throw new Error(`only 1 ciphertext rel8n allowed... (E: e8ab2ec38ad844dfb229efc5b8981946)`); }
+
+    //         // get ciphertext ibgib
+    //         const ciphertextAddr = encryptedSpace.rel8ns!.ciphertext![0];
+    //         const resCiphertext = await this.get({ addr: ciphertextAddr, space });
+    //         if (!resCiphertext.success) { throw new Error(`get ciphertext failed (E: e58b3471c0334cd7bc626998106e6547)`); }
+    //         if ((resCiphertext.ibGibs || []).length !== 1) { throw new Error(`get ciphertext retrieved non-1 length (eesh) (E: a3a1f00e827b4f88a42b4a7433cf1065)`); }
+    //         const ciphertextIbGib = resCiphertext.ibGibs![0] as CiphertextIbGib_V1;
+
+    //         // get secrets associated with enciphered space
+    //         if (!encryptedSpace.rel8ns?.secret) { throw new Error(`!encryptionIbGib.rel8ns?.secret (E: 8bfed1541976433da9402d7d3a9138dd)`); }
+    //         const secretAddrs = encryptedSpace.rel8ns!.secret!;
+    //         const localUserSpace = await this.getLocalUserSpace({});
+    //         if (!localUserSpace) { throw new Error(`(UNEXPECTED) could not get localUserSpace? (E: 3c5687a15b3b58e3dcf1eca4f5fe5723) (E: c123b340177647968e10a6b119d84d2b)`); }
+    //         const argGetSecrets = await localUserSpace.argy({
+    //             argData: { ibGibAddrs: secretAddrs, cmd: 'get', }
+    //         });
+    //         const resSecrets = await localUserSpace.witness(argGetSecrets);
+    //         if (!resSecrets.data?.success || (resSecrets.ibGibs || []).length === 0) {
+    //             throw new Error(`couldn't get secret ibgibs (E: cb17687f842f4296a9ecf89d9a568e46)`);
+    //         }
+    //         const secretIbGibs = resSecrets.ibGibs.concat() as IbGib_V1<SecretData_V1>[];
+
+    //         // get plaintext now that we have the ciphertext ibgib and secret ibgib(s)
+    //         const plaintextString = await this.getPlaintextString({
+    //             ciphertextIbGib,
+    //             fnPromptPassword,
+    //             dontPrompt,
+    //             secretIbGibs,
+    //             space,
+    //         });
+
+    //         const syncSpaceData = JSON.parse(plaintextString) as OuterSpaceData;
+    //         if (syncSpaceData.type !== 'sync') { throw new Error(`syncSpaceData.type !== 'sync'...this is the only one implemented right now (E: 509b2373d6f8445ebe5bd6f27f62af93)`); }
+    //         if (syncSpaceData.subtype !== 'aws-dynamodb') { throw new Error(`syncSpaceData.subtype !== 'aws-dynamodb'...only one right now dude (E: b5caaf3b4c60438eb2cee58ce8e1d3f6)`); }
+
+    //         // this is the original aws only implementation. I've just added (untested)
+    //         // a quick factory function where the consumer would do the following code.
+    //         const unwrappedSpace = await fnSpaceFactory(syncSpaceData);
+    //         return unwrappedSpace;
+    //         // so we have a syncspace data (only aws-dynamodb space right now).
+    //         // load this data into a space class with behavior (not just the dto).
+    //         // const awsSpace = new AWSDynamoSpace_V1(syncSpaceData, null);
+    //         // awsSpace.gib = await getGib({ ibGib: awsSpace, hasTjp: false });
+    //         // if (logalot) { console.log(`awsSpace.gib: ${awsSpace.gib}`); }
+    //         // return awsSpace;
+
+    //     } catch (error) {
+    //         console.error(`${lc} ${error.message}`);
+    //         throw error;
+    //     }
+    // }
 
     /**
      * Caching user password secret in memory only.
@@ -2300,113 +2314,110 @@ export abstract class MetaspaceBase implements MetaspaceService {
         }
     }
 
-    async getAppSyncSpaces({
-        unwrapEncrypted,
-        createIfNone,
-        dontPrompt,
-        space,
-        outerspaceIds,
-        fnSpaceFactory,
-        fnPromptSecret,
-        fnPromptEncryption,
-        fnPromptOuterSpace,
-    }: {
-        unwrapEncrypted: boolean,
-        createIfNone: boolean,
-        /**
-         * If true, don't prompt the user if we don't have it already cached.
-         *
-         * We don't want the user to hit the page and then always have to type in
-         * the password, just because my password code sucks atow.
-         */
-        dontPrompt?: boolean,
-        space?: IbGibSpaceAny,
-        /**
-         * @see {@link syncIbGibs} arg of the same name
-         */
-        outerspaceIds?: SpaceId[],
-        fnSpaceFactory: (unencryptedSpaceData: any) => Promise<IbGibSpaceAny>,
-        fnPromptSecret: (space: IbGibSpaceAny) => Promise<SecretIbGib_V1 | undefined>,
-        fnPromptEncryption: (space: IbGibSpaceAny) => Promise<EncryptionIbGib_V1 | undefined>,
-        fnPromptOuterSpace: (space: IbGibSpaceAny) => Promise<IbGibSpaceAny | undefined>,
-    }): Promise<IbGibSpaceAny[]> {
-        const lc = `${this.lc}[${this.getAppSyncSpaces.name}]`;
-        try {
-            // I don't want this pinging the user if we're on the welcome page.
-            dontPrompt = dontPrompt ?? documentLocationIsAtWelcomePage();
-
-            space = space ?? await this.getLocalUserSpace({});
-            if (!space) { throw new Error(`space falsy and localUserSpace not initialized (?) (E: bf09346708ba4d6e9a1389bd1b66d500)`); }
-
-            // get existing
-            let appSyncSpaces: IbGibSpaceAny[] =
-                await this.getSpecialRel8dIbGibs<IbGibSpaceAny>({
-                    type: "outerspaces",
-                    rel8nName: SYNC_SPACE_REL8N_NAME,
-                    space,
-                });
-
-            // filter if applicable
-            const hasOuterspaceIds = (outerspaceIds?.length ?? 0) > 0;
-            if (hasOuterspaceIds) {
-                appSyncSpaces = appSyncSpaces.filter(x => outerspaceIds!.includes(x.data!.uuid!));
-            }
-
-            // create if applicable
-            if (appSyncSpaces.length === 0) {
-                if (createIfNone) {
-                    if (hasOuterspaceIds) { throw new Error(`(UNEXPECTED) both createIfNone true and outerspaceIds (filter) also true? you cannot have both of these set, it's one of the other. (E: 9caaa121dee3e41e6e29916614cd4e24)`); }
-                    const createdReqs = await this._createOuterspaceAndRequiredIbGibs({
-                        space,
-                        fnPromptSecret,
-                        fnPromptEncryption,
-                        fnPromptOuterSpace,
-                    });
-                    if (createdReqs) {
-                        appSyncSpaces = await this.getSpecialRel8dIbGibs<IbGibSpaceAny>({
-                            type: "outerspaces",
-                            rel8nName: SYNC_SPACE_REL8N_NAME,
-                            space,
-                        });
-                    }
-                } else {
-                    throw new Error(`No sync spaces found. First create a sync outerspace (like a cloud sync space) in order to synchronize with it (E: 8f395f226ac7b558b9317befefbcb724)`);
-                }
-            }
-
-            // unwrap if requested
-            let resSpaces: IbGibSpaceAny[] = [];
-            if (unwrapEncrypted) {
-                for (let i = 0; i < appSyncSpaces.length; i++) {
-                    let syncSpace = appSyncSpaces[i];
-
-                    if (syncSpace.rel8ns) {
-                        if (syncSpace.rel8ns.ciphertext) {
-                            syncSpace = await this.unwrapEncryptedSyncSpace({
-                                encryptedSpace: syncSpace,
-                                fnPromptPassword: this.getFnPromptPassword!(),
-                                dontPrompt,
-                                space,
-                                fnSpaceFactory,
-                            });
-                        }
-
-                        resSpaces.push(syncSpace);
-                    } else {
-                    }
-
-                }
-            } else {
-                // still (probably) encrypted
-                resSpaces = appSyncSpaces;
-            }
-
-            return resSpaces;
-        } catch (error) {
-            console.error(`${lc} ${error.message}`);
-            return [];
-        }
-    }
+    // async getSyncSpaces({
+    //     createIfNone,
+    //     dontPrompt,
+    //     space,
+    //     outerspaceIds,
+    //     // fnSpaceFactory,
+    //     fnPromptSecret,
+    //     fnPromptEncryption,
+    //     fnPromptOuterSpace,
+    // }: {
+    //     // unwrapEncrypted: boolean,
+    //     createIfNone: boolean,
+    //     /**
+    //      * If true, don't prompt the user if we don't have it already cached.
+    //      *
+    //      * We don't want the user to hit the page and then always have to type in
+    //      * the password, just because my password code sucks atow.
+    //      */
+    //     dontPrompt?: boolean,
+    //     space?: IbGibSpaceAny,
+    //     /**
+    //      * @see {@link syncIbGibs} arg of the same name
+    //      */
+    //     outerspaceIds?: SpaceId[],
+    //     // fnSpaceFactory: (unencryptedSpaceData: any) => Promise<IbGibSpaceAny>,
+    //     fnPromptSecret: (space: IbGibSpaceAny) => Promise<SecretIbGib_V1 | undefined>,
+    //     fnPromptEncryption: (space: IbGibSpaceAny) => Promise<EncryptionIbGib_V1 | undefined>,
+    //     fnPromptOuterSpace: (space: IbGibSpaceAny) => Promise<IbGibSpaceAny | undefined>,
+    // }): Promise<SyncSpaceIbGib[]> {
+    //     const lc = `${this.lc}[${this.getSyncSpaces.name}]`;
+    //     try {
+    //         space = space ?? await this.getLocalUserSpace({});
+    //         if (!space) { throw new Error(`space falsy and localUserSpace not initialized (?) (E: bf09346708ba4d6e9a1389bd1b66d500)`); }
+
+    //         // get existing
+    //         let resSyncSpaces: SyncSpaceIbGib[] =
+    //             await this.getSpecialRel8dIbGibs<SyncSpaceIbGib>({
+    //                 type: "outerspaces",
+    //                 rel8nName: SYNC_SPACE_REL8N_NAME,
+    //                 space,
+    //             });
+
+    //         // filter if applicable
+    //         const hasOuterspaceIds = (outerspaceIds?.length ?? 0) > 0;
+    //         if (hasOuterspaceIds) {
+    //             resSyncSpaces = resSyncSpaces.filter(x => outerspaceIds!.includes(x.data!.uuid!));
+    //         }
+
+    //         // create if applicable
+    //         if (resSyncSpaces.length === 0) {
+    //             if (createIfNone) {
+    //                 if (hasOuterspaceIds) { throw new Error(`(UNEXPECTED) both createIfNone true and outerspaceIds (filter) also true? you cannot have both of these set, it's one of the other. (E: 9caaa121dee3e41e6e29916614cd4e24)`); }
+    //                 const createdReqs = await this._createOuterspaceAndRequiredIbGibs({
+    //                     space,
+    //                     fnPromptSecret,
+    //                     fnPromptEncryption,
+    //                     fnPromptOuterSpace,
+    //                 });
+    //                 if (createdReqs) {
+    //                     resSyncSpaces = await this.getSpecialRel8dIbGibs<SyncSpaceIbGib>({
+    //                         type: "outerspaces",
+    //                         rel8nName: SYNC_SPACE_REL8N_NAME,
+    //                         space,
+    //                     });
+    //                 }
+    //             } else {
+    //                 throw new Error(`No sync spaces found. First create a sync outerspace (like a cloud sync space) in order to synchronize with it (E: 8f395f226ac7b558b9317befefbcb724)`);
+    //             }
+    //         }
+
+    //         // unwrap if requested
+    //         // let resSpaces: SyncSpaceIbGib[] = [];
+    //         // if (unwrapEncrypted) {
+    //         //     for (let i = 0; i < syncSpaceIbGibs.length; i++) {
+    //         //         let syncSpace = syncSpaceIbGibs[i];
+
+    //         //         if (syncSpace.rel8ns) {
+    //         //             if (syncSpace.rel8ns.ciphertext) {
+    //         //                 syncSpace = await this.unwrapEncryptedSyncSpace({
+    //         //                     encryptedSpace: syncSpace,
+    //         //                     fnPromptPassword: this.getFnPromptPassword!(),
+    //         //                     dontPrompt,
+    //         //                     space,
+    //         //                     fnSpaceFactory,
+    //         //                 });
+    //         //             }
+
+    //         //             resSpaces.push(syncSpace);
+    //         //         } else {
+    //         //         }
+
+    //         //     }
+    //         // } else {
+    //         // still (probably) encrypted
+    //         // resSpaces = syncSpaceIbGibs;
+    //         // }
+
+    //         // return resSpaces;
+    //         return resSyncSpaces;
+    //     } catch (error) {
+    //         console.error(`${lc} ${error.message}`);
+    //         return [];
+    //     }
+    // }
 
     // async createRobbotIbGib({
     //   robbotData,
@@ -2576,39 +2587,22 @@ export abstract class MetaspaceBase implements MetaspaceService {
 
     async syncIbGibs({
         dependencyGraphIbGibs,
-        // confirm,
+        syncSpaceIbGibs,
         // watch,
-        outerspaceIds,
-        fnPreSyncProgress,
-        fnSpaceFactory,
-        fnPromptSecret,
-        fnPromptEncryption,
-        fnPromptOuterSpace,
     }: {
+        /**
+         * @see {@link MetaspaceService.syncIbGibs}
+         */
         dependencyGraphIbGibs?: IbGib_V1[],
-        // confirm?: boolean,
+        /**
+         * @see {@link MetaspaceService.syncIbGibs}
+         */
+        syncSpaceIbGibs: IbGibSpaceAny[],
         // /**
         //  * If true, will watch ibgibs in dependency graph that have timelines
         //  * (tjps).
         //  */
         // watch?: boolean,
-        /**
-         * if provided, these will determine which outerspace(s) we will sync
-         * the {@link dependencyGraphIbGibs} with.
-         */
-        outerspaceIds?: SpaceId[],
-        /**
-         * The meat of the sync process is tracked via a status within the sync
-         * spaces themselves. I'm addign this fn to track the pre and post progress
-         * stuff, since decrypting takes some time, and building the dependency
-         * graphs takes time. Both of these happen before the actual syncing occurs
-         * in the spaces.
-         */
-        fnPreSyncProgress?: (msg: string) => Promise<void>,
-        fnSpaceFactory: (unencryptedSpaceData: any) => Promise<IbGibSpaceAny>,
-        fnPromptSecret: (space: IbGibSpaceAny) => Promise<SecretIbGib_V1 | undefined>,
-        fnPromptEncryption: (space: IbGibSpaceAny) => Promise<EncryptionIbGib_V1 | undefined>,
-        fnPromptOuterSpace: (space: IbGibSpaceAny) => Promise<IbGibSpaceAny | undefined>,
     }): Promise<SyncSagaInfo[] | undefined> {
         const lc = `${this.lc}[${this.syncIbGibs.name}]`;
         // map of saga infos across all spaces
@@ -2655,7 +2649,8 @@ export abstract class MetaspaceBase implements MetaspaceService {
 
             // #region validate
             if (logalot) { console.log(`${lc} starting...`); }
-            if (!dependencyGraphIbGibs || dependencyGraphIbGibs.length === 0) { throw new Error(`ibGibs required. (E: 404c36475fb84fc285a23a67c0b8fcb2)`); }
+            if (!dependencyGraphIbGibs || dependencyGraphIbGibs.length === 0) { throw new Error(`dependencyGraphIbGibs required. (E: 404c36475fb84fc285a23a67c0b8fcb2)`); }
+            if (!syncSpaceIbGibs || syncSpaceIbGibs.length === 0) { throw new Error(`syncSpaceIbGibs required (E: c5a022454b9ce34856e141e61e337d24)`); }
             // #endregion
 
             const localUserSpace = await this.getLocalUserSpace({});
@@ -2664,52 +2659,20 @@ export abstract class MetaspaceBase implements MetaspaceService {
 
             // #region get sync spaces and build participant infos
             if (logalot) { console.log(`${lc} get sync spaces (returns if none)`); }
-            console.timeLog(syncTimelogName, 'getAppSyncSpaces starting (unwrapEncrypted is true) starting...');
-            if (fnPreSyncProgress) { fnPreSyncProgress('getting app sync spaces... (I: aa2e8f32ab26457bad703218aa7fb47d)'); }
-            const appSyncSpaces: IbGibSpaceAny[] = await this.getAppSyncSpaces({
-                unwrapEncrypted: true,
-                createIfNone: true,
-                space: localUserSpace,
-                outerspaceIds,
-                fnSpaceFactory,
-                fnPromptSecret,
-                fnPromptEncryption,
-                fnPromptOuterSpace,
-            });
-            if (fnPreSyncProgress) { fnPreSyncProgress('build complete. (I: 391a9aa7749d45b1aecf9a0010d9937f)'); }
-            console.timeLog(syncTimelogName, 'getAppSyncSpaces starting (unwrapEncrypted is true) complete.');
-            if (appSyncSpaces.length === 0) {
-                const msg = `Hmm, we seem to not have any sync spaces, and we can't exactly sync without them. Sometimes this is because of a wrong password? (I: 902bd3e00c3246abb646a750f2f2b782)`;
-                if (logalot) { console.log(`${lc} ${msg}`) };
-                const fnAlert = this.getFnAlert!();
-                await fnAlert({ title: "Sync Cancelled", msg });
-                this._syncing = false;
-                console.timeLog(syncTimelogName, 'cancelled');
-                console.timeEnd(syncTimelogName);
-                return undefined; /* <<<< returns early */
-            }
-            // const localUserSpace = await this.getLocalUserSpace({});
             const participants: ParticipantInfo[] = [
                 // local user space is the src
                 { id: localUserSpace.data.uuid, gib: localUserSpace.gib, s_d: 'src', },
 
                 // each sync space is a destination
-                ...appSyncSpaces.map(s => {
-                    if (!s.data) { throw new Error(`space.data required. (E: 3c192771e84445a4b6476d5193b07e9d)`); }
-                    if (!s.data.uuid) { throw new Error(`space.data.uuid required. (E: d27e9998227840f99d45a3ed245f3196)`); }
-                    if (!s.gib) { throw new Error(`space.gib required. (E: db73aceb2f8445d8964ae49b59957072)`); }
-                    return { id: s.data.uuid, gib: s.gib, s_d: 'dest', } as ParticipantInfo;
+                ...syncSpaceIbGibs.map(s => {
+                    if (!s.data) { throw new Error(`syncSpaceIbGib.data required. (E: 3c192771e84445a4b6476d5193b07e9d)`); }
+                    if (!s.data.uuid) { throw new Error(`syncSpaceIbGib.data.uuid required. (E: d27e9998227840f99d45a3ed245f3196)`); }
+                    if (!s.gib) { throw new Error(`syncSpaceIbGib.gib required. (E: db73aceb2f8445d8964ae49b59957072)`); }
+                    return { id: s.data.uuid, gib: s.gib, s_d: 'dest', } satisfies ParticipantInfo;
                 }),
             ];
             // #endregion
 
-            // if (fnPreSyncProgress) { fnPreSyncProgress('building dependency graph... (I: ae178a39c2594557b6d0489b02336ecd)'); }
-            // get **ALL** ibgibs that we'll need to put/merge
-            // const allIbGibsToSync: { [addr: string]: IbGib_V1 } = {};
-            // dependencyGraphIbGibs.forEach(x => { allIbGibsToSync[getIbGibAddr({ ibGib: x })] = x });
-
-            // await this._getAllIbGibsToSyncFromGraph({ dependencyGraphIbGibs, space: localUserSpace });
-
             // _NOW_ we can finally put/merge into sync spaces.
             // this returns to us the most recent versions which we can update
             // our local timelines if we so choose (which we will).
@@ -2720,7 +2683,7 @@ export abstract class MetaspaceBase implements MetaspaceService {
             if (logalot) { console.log(`${lc} syncing to spaces in parallel...`); }
             const multiSpaceOpId = await getUUID();
             const allSagaInfos: SyncSagaInfo[] = [];
-            const startSyncPromises: Promise<void>[] = appSyncSpaces.map(async syncSpace => {
+            const startSyncPromises: Promise<void>[] = syncSpaceIbGibs.map(async syncSpace => {
                 // create the info that will track progress over entire sync saga
                 const sagaInfo =
                     await this._createNewSyncSagaInfo({
@@ -2765,21 +2728,21 @@ export abstract class MetaspaceBase implements MetaspaceService {
             return allSagaInfos;
         } catch (error) {
             console.error(`${lc} ${error.message}`);
-            await this.finalizeAllSyncSagas_NoThrow({ error });
+            await this._finalizeAllSyncSagas_NoThrow({ error });
             throw error;
         } finally {
             if (logalot) { console.log(`${lc} complete.`); }
         }
     }
 
-    protected async finalizeSyncSaga({
+    protected async _finalizeSyncSaga({
         sagaInfo,
         error,
     }: {
         sagaInfo: SyncSagaInfo,
         error?: any,
     }): Promise<void> {
-        const lc = `${this.lc}[${this.finalizeSyncSaga.name}]`;
+        const lc = `${this.lc}[${this._finalizeSyncSaga.name}]`;
         try {
             if (logalot) { console.log(`${lc} starting...`); }
             if (sagaInfo.complete) { return; }
@@ -2828,18 +2791,18 @@ export abstract class MetaspaceBase implements MetaspaceService {
         }
     }
 
-    protected async finalizeAllSyncSagas_NoThrow({
+    protected async _finalizeAllSyncSagas_NoThrow({
         error,
     }: {
         error?: any,
     }): Promise<void> {
-        const lc = `${this.lc}[${this.finalizeAllSyncSagas_NoThrow.name}]`;
+        const lc = `${this.lc}[${this._finalizeAllSyncSagas_NoThrow.name}]`;
         try {
             const syncSagaInfos_NotComplete =
                 Object.values(this.sagaInfoMap).filter(x => !x.complete);
             for (let i = 0; i < syncSagaInfos_NotComplete.length; i++) {
                 const sagaInfo = syncSagaInfos_NotComplete[i];
-                await this.finalizeSyncSaga({ sagaInfo, error });
+                await this._finalizeSyncSaga({ sagaInfo, error });
             }
         } catch (error) {
             console.error(`${lc}(UNEXPECTED) ${error.message}`);
@@ -2966,18 +2929,10 @@ export abstract class MetaspaceBase implements MetaspaceService {
     protected async _startSync({
         syncSagaInfo,
         // watch,
-        // confirm,
         syncTimelogName,
     }: {
         syncSagaInfo: SyncSagaInfo,
         // watch?: boolean,
-        /**
-         * Will confirm via checking existence of ibgibs in sync space after
-         * writing them.
-         *
-         * NOTE: IGNORED ATM
-         */
-        // confirm?: boolean,
         syncTimelogName: string,
     }): Promise<SyncSpaceResultIbGib> {
         const lc = `${this.lc}[${this._startSync.name}]`;
@@ -3102,7 +3057,7 @@ export abstract class MetaspaceBase implements MetaspaceService {
                             const emsg = `${lc}(sagaId: ${sagaInfo.sagaId}) syncStatus$.error: ${error}`;
                             console.error(emsg);
                             // await this.getFnAlert!()({title: 'couldnt this.syncIbGibs...', msg: emsg});
-                            await this.finalizeSyncSaga({ sagaInfo, error: emsg });
+                            await this._finalizeSyncSaga({ sagaInfo, error: emsg });
                         },
                         complete: async () => {
                             if (logalot) { console.log(`${lc}(sagaId: ${sagaInfo.sagaId}) syncStatus$.complete.`); }
@@ -3160,11 +3115,11 @@ export abstract class MetaspaceBase implements MetaspaceService {
                     break;
 
                 case StatusCode.merged_dna:
-                    await this.handleSyncStatus_Merged({ status });
+                    await this._handleSyncStatus_Merged({ status });
                     break;
 
                 case StatusCode.merged_state:
-                    await this.handleSyncStatus_Merged({ status });
+                    await this._handleSyncStatus_Merged({ status });
                     break;
 
                 case StatusCode.already_synced:
@@ -3173,7 +3128,7 @@ export abstract class MetaspaceBase implements MetaspaceService {
                     break;
 
                 case StatusCode.completed:
-                    await this.handleSyncStatus_Complete({ sagaInfo });
+                    await this._handleSyncStatus_Complete({ sagaInfo });
                     break;
 
                 case StatusCode.undefined:
@@ -3195,12 +3150,12 @@ export abstract class MetaspaceBase implements MetaspaceService {
         }
     };
 
-    protected async handleSyncStatus_Merged({
+    protected async _handleSyncStatus_Merged({
         status,
     }: {
         status: SyncStatusIbGib,
     }): Promise<void> {
-        const lc = `${this.lc}[${this.handleSyncStatus_Merged.name}]`;
+        const lc = `${this.lc}[${this._handleSyncStatus_Merged.name}]`;
         try {
             if (logalot) { console.log(`${lc} starting...`); }
             // #region validate
@@ -3284,24 +3239,24 @@ export abstract class MetaspaceBase implements MetaspaceService {
         }
     }
 
-    protected async handleSyncStatus_Complete({
+    protected async _handleSyncStatus_Complete({
         sagaInfo,
     }: {
         sagaInfo: SyncSagaInfo,
     }): Promise<void> {
-        const lc = `${this.lc}[${this.handleSyncStatus_Complete.name}]`;
+        const lc = `${this.lc}[${this._handleSyncStatus_Complete.name}]`;
         try {
             // cleanup just this saga, which corresponds to a single sync space.
-            await this.finalizeSyncSaga({ sagaInfo });
+            await this._finalizeSyncSaga({ sagaInfo });
 
             // if this is the last saga across all spaces, clean up the rest.
             const allSagaInfos = Object.values(this.sagaInfoMap);
             if (allSagaInfos.every(x => x.complete)) {
-                await this.finalizeAllSyncSagas_NoThrow({});
+                await this._finalizeAllSyncSagas_NoThrow({});
             }
         } catch (error) {
             console.error(`${lc} ${error.message}`);
-            await this.finalizeAllSyncSagas_NoThrow({ error });
+            await this._finalizeAllSyncSagas_NoThrow({ error });
         }
     }
 
@@ -3433,97 +3388,97 @@ export abstract class MetaspaceBase implements MetaspaceService {
         }
     }
 
-    protected async handleWatchTjpUpdates({
-        updates,
-        outerSpace,
-        localUserSpace,
-    }: {
-        updates: { [tjpAddr: string]: IbGibAddr; }
-        outerSpace: IbGibSpaceAny,
-        localUserSpace: IbGibSpaceAny,
-    }): Promise<void> {
-        const lc = `${this.lc}[${this.handleWatchTjpUpdates.name}]`;
-        if (logalot) { console.log(`${lc} starting...`); }
-        try {
-            if (!outerSpace.data) { throw new Error(`outerSpace.data falsy (E: b5fde89e87bef9b8b6ce38e24be4a823)`); }
-
-            /**
-             * compile list of addrs we have locally for all updates, so we don't try
-             * to download them from outer space unnecessarily.
-             */
-            const latestAddrsLocallyWithUpdate: IbGibAddr[] = [];
-            const tjpAddrs = Object.keys(updates);
-            const latestAddrs_Store = Object.values(updates);
-            for (let i = 0; i < tjpAddrs.length; i++) {
-                const tjpAddr = tjpAddrs[i];
-                if (logalot) { console.log(`${lc} tjpAddr: ${tjpAddr}`); }
-                const latestAddrLocally = await this.getLatestAddr({ tjpAddr }) ?? tjpAddr;
-                if (
-                    !latestAddrs_Store.includes(latestAddrLocally) &&
-                    !latestAddrsLocallyWithUpdate.includes(latestAddrLocally)
-                ) {
-                    latestAddrsLocallyWithUpdate.push(latestAddrLocally);
-                }
-            }
-            if (latestAddrsLocallyWithUpdate.length === 0) {
-                if (logalot) { console.log(`${lc} latestAddrsLocallyWithUpdate.length === 0. We already had all of the updates locally perhaps. Returning early. (I: 844193c515084d0ebc348349f1ac41f4)`); }
-                return; /* <<<< returns early */
-            }
-
-            /**
-             * LOCAL dependencies for latest LOCAL addrs for all tjpAddrs in updates.
-             */
-            const localDependencyGraphs = await this.getDependencyGraph({
-                ibGibAddrs: latestAddrsLocallyWithUpdate,
-                live: true,
-                maxRetries: DEFAULT_MAX_RETRIES_GET_DEPENDENCY_GRAPH_OUTERSPACE,
-                msBetweenRetries: DEFAULT_MS_BETWEEN_RETRIES_GET_DEPENDENCY_GRAPH_OUTERSPACE,
-                space: localUserSpace,
-            });
-
-            /** all addrs we already have locally */
-            const addrsAlreadyStoredLocally = Object.keys(localDependencyGraphs);
-
-            // get dependency graph from outer space, skipping all addrs in local already
-            const newerAddrsFromOuterSpace: IbGibAddr[] = Object.values(updates);
-            const newerIbGibDependencyGraphFromOuterSpace = await getDependencyGraph({
-                ibGibAddrs: newerAddrsFromOuterSpace,
-                live: false,
-                skipAddrs: addrsAlreadyStoredLocally,
-                space: outerSpace,
-            });
-            const newerIbGibsFromOuterSpace: IbGib_V1[] =
-                Object.values(newerIbGibDependencyGraphFromOuterSpace);
-
-            if (logalot) { console.log(`${lc} got ${newerIbGibsFromOuterSpace.length} ibGibs from outerspace`); }
-
-            // save locally
-            if (logalot) { console.log(`${lc} saving new ibgibs from outerspace in local space...`); }
-            if (newerIbGibsFromOuterSpace.length > 0) {
-                await this.put({ ibGibs: newerIbGibsFromOuterSpace });
-
-                // register the newest tjp ibGibs locally
-                if (logalot) { console.log(`${lc} registering "new" updated tjp ibgibs locally...`); }
-                for (let i = 0; i < tjpAddrs.length; i++) {
-                    const tjpAddr = tjpAddrs[i];
-                    const updatedAddr = updates[tjpAddr];
-                    if (!addrsAlreadyStoredLocally.includes(updatedAddr)) {
-                        const updatedIbGib = newerIbGibDependencyGraphFromOuterSpace[updatedAddr];
-                        if (!updatedIbGib) {
-                            throw new Error(`did not get updatedIbGib (${updatedAddr}) from outerspace (${outerSpace.data.uuid}) (E: 818de70f5b444a3ba198ba6480a15b04)`);
-                        }
-                        await this.registerNewIbGib({ ibGib: updatedIbGib });
-                    }
-                }
-            }
-
-        } catch (error) {
-            console.error(`${lc} ${error.message}`);
-            // does not rethrow
-        } finally {
-            if (logalot) { console.log(`${lc} complete.`); }
-        }
-    }
+    // protected async handleWatchTjpUpdates({
+    //     updates,
+    //     outerSpace,
+    //     localUserSpace,
+    // }: {
+    //     updates: { [tjpAddr: string]: IbGibAddr; }
+    //     outerSpace: IbGibSpaceAny,
+    //     localUserSpace: IbGibSpaceAny,
+    // }): Promise<void> {
+    //     const lc = `${this.lc}[${this.handleWatchTjpUpdates.name}]`;
+    //     if (logalot) { console.log(`${lc} starting...`); }
+    //     try {
+    //         if (!outerSpace.data) { throw new Error(`outerSpace.data falsy (E: b5fde89e87bef9b8b6ce38e24be4a823)`); }
+
+    //         /**
+    //          * compile list of addrs we have locally for all updates, so we don't try
+    //          * to download them from outer space unnecessarily.
+    //          */
+    //         const latestAddrsLocallyWithUpdate: IbGibAddr[] = [];
+    //         const tjpAddrs = Object.keys(updates);
+    //         const latestAddrs_Store = Object.values(updates);
+    //         for (let i = 0; i < tjpAddrs.length; i++) {
+    //             const tjpAddr = tjpAddrs[i];
+    //             if (logalot) { console.log(`${lc} tjpAddr: ${tjpAddr}`); }
+    //             const latestAddrLocally = await this.getLatestAddr({ tjpAddr }) ?? tjpAddr;
+    //             if (
+    //                 !latestAddrs_Store.includes(latestAddrLocally) &&
+    //                 !latestAddrsLocallyWithUpdate.includes(latestAddrLocally)
+    //             ) {
+    //                 latestAddrsLocallyWithUpdate.push(latestAddrLocally);
+    //             }
+    //         }
+    //         if (latestAddrsLocallyWithUpdate.length === 0) {
+    //             if (logalot) { console.log(`${lc} latestAddrsLocallyWithUpdate.length === 0. We already had all of the updates locally perhaps. Returning early. (I: 844193c515084d0ebc348349f1ac41f4)`); }
+    //             return; /* <<<< returns early */
+    //         }
+
+    //         /**
+    //          * LOCAL dependencies for latest LOCAL addrs for all tjpAddrs in updates.
+    //          */
+    //         const localDependencyGraphs = await this.getDependencyGraph({
+    //             ibGibAddrs: latestAddrsLocallyWithUpdate,
+    //             live: true,
+    //             maxRetries: DEFAULT_MAX_RETRIES_GET_DEPENDENCY_GRAPH_OUTERSPACE,
+    //             msBetweenRetries: DEFAULT_MS_BETWEEN_RETRIES_GET_DEPENDENCY_GRAPH_OUTERSPACE,
+    //             space: localUserSpace,
+    //         });
+
+    //         /** all addrs we already have locally */
+    //         const addrsAlreadyStoredLocally = Object.keys(localDependencyGraphs);
+
+    //         // get dependency graph from outer space, skipping all addrs in local already
+    //         const newerAddrsFromOuterSpace: IbGibAddr[] = Object.values(updates);
+    //         const newerIbGibDependencyGraphFromOuterSpace = await getDependencyGraph({
+    //             ibGibAddrs: newerAddrsFromOuterSpace,
+    //             live: false,
+    //             skipAddrs: addrsAlreadyStoredLocally,
+    //             space: outerSpace,
+    //         });
+    //         const newerIbGibsFromOuterSpace: IbGib_V1[] =
+    //             Object.values(newerIbGibDependencyGraphFromOuterSpace);
+
+    //         if (logalot) { console.log(`${lc} got ${newerIbGibsFromOuterSpace.length} ibGibs from outerspace`); }
+
+    //         // save locally
+    //         if (logalot) { console.log(`${lc} saving new ibgibs from outerspace in local space...`); }
+    //         if (newerIbGibsFromOuterSpace.length > 0) {
+    //             await this.put({ ibGibs: newerIbGibsFromOuterSpace });
+
+    //             // register the newest tjp ibGibs locally
+    //             if (logalot) { console.log(`${lc} registering "new" updated tjp ibgibs locally...`); }
+    //             for (let i = 0; i < tjpAddrs.length; i++) {
+    //                 const tjpAddr = tjpAddrs[i];
+    //                 const updatedAddr = updates[tjpAddr];
+    //                 if (!addrsAlreadyStoredLocally.includes(updatedAddr)) {
+    //                     const updatedIbGib = newerIbGibDependencyGraphFromOuterSpace[updatedAddr];
+    //                     if (!updatedIbGib) {
+    //                         throw new Error(`did not get updatedIbGib (${updatedAddr}) from outerspace (${outerSpace.data.uuid}) (E: 818de70f5b444a3ba198ba6480a15b04)`);
+    //                     }
+    //                     await this.registerNewIbGib({ ibGib: updatedIbGib });
+    //                 }
+    //             }
+    //         }
+
+    //     } catch (error) {
+    //         console.error(`${lc} ${error.message}`);
+    //         // does not rethrow
+    //     } finally {
+    //         if (logalot) { console.log(`${lc} complete.`); }
+    //     }
+    // }
 
     // #endregion syncIbGibs related