@ibgib/core-gib 0.0.7 → 0.0.10

package/src/common/form/form-helper.mts

@@ -1,9 +1,8 @@
 
 import { getRegExp, UUID_REGEXP } from '@ibgib/helper-gib';
-// import { DynamicForm, FormItemInfo } from '../../ibgib-forms/types/form-items';
-import { GLOBAL_LOG_A_LOT, SAFE_SPECIAL_CHARS } from '../../core-constants.mjs';
+
 import { DynamicForm, FormItemInfo } from './form-items.mjs';
-// import { getRegExp } from './utils';
+import { GLOBAL_LOG_A_LOT, SAFE_SPECIAL_CHARS } from '../../core-constants.mjs';
 
 const logalot = GLOBAL_LOG_A_LOT || false;
 
@@ -16,6 +15,7 @@ const logalot = GLOBAL_LOG_A_LOT || false;
  */
 export class DynamicFormBuilder {
     protected lc: string = `[${DynamicFormBuilder.name}]`;
+
     protected items: FormItemInfo[] = [];
     protected what: string = '';
     /**
@@ -250,4 +250,3 @@ export class DynamicFormBuilder {
         } as DynamicForm;
     }
 }
-

package/src/core-constants.mts

@@ -495,8 +495,6 @@ export const SIMPLE_CONFIG_KEY_ROBBOT_SELECTED_ADDR = 'robbotBarSelectedAddr';
 
 // #region app
 
-export const APP_NAME_REGEXP = /^[a-zA-Z0-9_\-.]{1,32}$/;
-export const APP_REL8N_NAME = 'app';
 export const DEFAULT_APP_ICON = 'apps-outline';
 
 // #endregion app

package/src/core-helper.respec.mts

@@ -0,0 +1,71 @@
+import {
+    firstOfEach, firstOfAll, ifWe,
+    lastOfEach, lastOfAll,
+    ifWeMight, iReckon, respecfully
+} from '@ibgib/helper-gib/dist/respec-gib/respec-gib.mjs';
+const maam = `[${import.meta.url}]`, sir = maam;
+
+let crypto = globalThis.crypto;
+let { subtle } = crypto;
+
+import { IbGib_V1 } from '@ibgib/ts-gib/dist/V1/types.mjs';
+
+import { fooClone, fooFactory, fooGetIbAndGib } from './core-helper.mjs';
+
+/**
+ * Test helper functions.
+ */
+
+await respecfully(sir, `foo clone`, async () => {
+
+    await ifWe(sir, `should foo Clone yo (testing node/browser isomorphic packages)`, () => {
+        let obj = 1;
+        let clone = fooClone(obj);
+        iReckon(sir, clone).asTo('clone foo yo').isGonnaBe(obj);
+        // expect(1).asTo('expected fail test case').isGonnaBe(2);
+    });
+
+    await ifWe(sir, `should foo getibAndGib yo (testing node/browser isomorphic packages)`, () => {
+        let result = fooGetIbAndGib();
+        iReckon(sir, result.ib).asTo('ib').isGonnaBe('ib');
+    });
+
+    await ifWe(sir, `should foo factory yo (testing node/browser isomorphic packages)`, async () => {
+        let result = await fooFactory();
+        iReckon(sir, result).asTo('result').isGonnaBeTruthy();
+        iReckon(sir, result.ib).asTo('result.ib').isGonnaBeTruthy();
+    });
+
+});
+
+async function hash({
+    s,
+}: {
+    s: string,
+}): Promise<string> {
+    if (!s) { return ''; }
+    let algorithm = 'SHA-256';
+
+    try {
+        const msgUint8 = new TextEncoder().encode(s);
+        const buffer = await subtle.digest(algorithm, msgUint8);
+        const asArray = Array.from(new Uint8Array(buffer));
+        return asArray.map(b => b.toString(16).padStart(2, '0')).join('');
+    } catch (e) {
+        console.error(e.message ?? e);
+        throw e;
+    }
+}
+
+await respecfully(sir, `non-ts-gib isomorphic crypto hashing`, async () => {
+
+    await ifWe(sir, `should digest simple string consistently using crypto.subtle directly `, async () => {
+        let h = await hash({ s: '42' });
+        iReckon(sir, h).asTo('42').isGonnaBe('73475cb40a568e8da8a045ced110137e159f890ac4da883b6b17dc651b3a8049');
+    });
+    await ifWe(sir, `should digest simple stringified ibgib consistently using crypto.subtle directly `, async () => {
+        let ibgib: IbGib_V1 = { ib: 'ib', gib: 'gib' };
+        let h = await hash({ s: JSON.stringify(ibgib) }); // doesn't use ts-gib but consistent stringifying json is important
+        iReckon(sir, h).asTo('ib^gib').isGonnaBe('cbad0694a257358c044611ea1fa88ace71a01a9b8409d2354d0387d8043f7671');
+    });
+});

package/src/core-types.mts

@@ -1,4 +1,8 @@
 import { Observable } from 'rxjs';
+
+import { IbGibAddr, TransformResult } from '@ibgib/ts-gib';
+import { IbGib_V1 } from '@ibgib/ts-gib/dist/V1/index.mjs';
+
 import {
   DeleteIbGibOpts, DeleteIbGibResult, GetIbGibOpts, GetIbGibResult,
   IbGibTimelineUpdateInfo, PutIbGibOpts, PutIbGibResult,
@@ -6,12 +10,10 @@ import {
 } from './common/other/other-types.mjs';
 import { SpaceId } from './witness/space/space-types.mjs';
 import { RobbotIbGib_V1, RobbotPromptResult } from './witness/robbot/robbot-types.mjs';
-import { IbGib_V1 } from '@ibgib/ts-gib/dist/V1/index.mjs';
 import { PicIbGib_V1, UpdatePicPromptResult } from './common/pic/pic-types.mjs';
 import { CommentIbGib_V1, UpdateCommentPromptResult } from './common/comment/comment-types.mjs';
 import { AppIbGib_V1, AppPromptResult } from './witness/app/app-types.mjs';
 import { RootData } from './common/root/root-types.mjs';
-import { IbGibAddr, TransformResult } from '@ibgib/ts-gib';
 import { GetDependencyGraphOptions } from './common/other/graph-helper.mjs';
 import { CiphertextIbGib_V1, EncryptionData_V1, SecretData_V1, SecretIbGib_V1 } from './common/encrypt/encrypt-types.mjs';
 import { SyncSagaInfo } from './witness/space/outer-space/outer-space-types.mjs';
@@ -517,3 +519,23 @@ export interface IbGibLocalSpaceService_AllPowerful {
     space?: IbGibSpaceAny,
   }): Promise<void>;
 }
+
+
+/**
+ * Function (provider?) that alerts the user of a given `title` and `msg`.
+ */
+export type AlertFunction = ({ title, msg }: { title: string, msg: string }) => Promise<void>;
+
+/**
+ * Function (provider?) that returns user text, prompting with the given `title` and `msg`.
+ */
+export type PromptFunction = ({ title, msg }: { title: string, msg: string }) => Promise<string | null>;
+
+/**
+ * Function (provider?) that returns a password, prompting with the given `title` and `msg`.
+ *
+ * This is the same atow as the {@link PromptFunction}.
+ *
+ * In the future, maybe a prompt signature with a `private` param would be more appropriate/DRY.
+ */
+export type PromptPasswordFunction = PromptFunction;

package/src/respec-gib.node.mts

@@ -0,0 +1,199 @@
+import { readdir, open } from 'node:fs/promises';
+import { statSync } from 'node:fs';
+import * as pathUtils from 'path';
+
+import { pretty } from '@ibgib/helper-gib';
+import { getGlobalRespecGib } from '@ibgib/helper-gib/dist/respec-gib/respec-gib.mjs';
+
+// #region settings
+/**
+ * This is how I enable/disable verbose logging. Do with it what you will.
+ */
+const logalot = false;
+
+/** set this to the root of the respecs to look at */
+const RESPEC_ROOT_DIR_RELATIVE_TO_BASE = './dist';
+
+/** change this to suit your naming convention */
+const RESPEC_FILE_REG_EXP = /^.+respec\.mjs$/;
+// const RESPEC_FILE_REG_EXP = /^.*respec-gib.respec\.mjs$/;
+// if (respecPath.includes('respec-gib.respec.mjs')) {
+
+/**
+ * If on, will first load a file and see if there is an extra respecful
+ * `await respecfully`/`ifWe` block. Use these if you want to focus on a single or
+ * subset of respecs.
+ *
+ * If there are no extra respecful blocks found in an entire file, that file
+ * will be skipped.
+ *
+ * Note: this only is a flag to search through respec files.
+ */
+const LOOK_FOR_EXTRA_RESPEC = true;
+/**
+ * The names of the functions that indicate that we want to focus on just those
+ * blocks.
+ *
+ * ATOW, for first run implementation here, I am implementing it such that it
+ * will filter out files that don't have these indicators. The respec files that
+ * do have these will execute fully, but the output will only include these
+ * particular blocks.
+ */
+const EXTRA_RESPEC_FUNCTION_NAMES: string[] = ['await respecfullyDear', 'ifWeMight'];
+
+// #endregion settings
+
+// #region 1. get respec paths
+
+const basePath = process.cwd();
+const srcPath = pathUtils.join(basePath, RESPEC_ROOT_DIR_RELATIVE_TO_BASE);
+
+if (logalot) { console.log(`cwd: ${process.cwd()}`); }
+if (logalot) { console.log(`basePath: ${basePath}`); }
+if (logalot) { console.log(`srcPath: ${srcPath}`); }
+
+
+const respecGib = getGlobalRespecGib();
+const allRespecPaths = await getRespecFileFullPaths(srcPath, []);
+
+if (logalot) { console.log(`allRespecPaths: ${allRespecPaths} (I: f5182a455375a8cf2aa6e1127a082423)`); }
+let filteredRespecPaths: string[] | undefined = undefined;
+
+if (LOOK_FOR_EXTRA_RESPEC) {
+    const hasExtraRespecPromises = allRespecPaths.map(async respecPath => {
+        const hasExtra = await respecFileHasExtraRespec(respecPath);
+        return [respecPath, hasExtra] as [string, boolean];
+    });
+    const resPathHasExtraTuples = await Promise.all(hasExtraRespecPromises);
+    filteredRespecPaths = resPathHasExtraTuples
+        .filter(([_respecPath, hasExtra]) => hasExtra)
+        .map(([respecPath, _hasExtra]) => respecPath);
+
+    // if there are no files that have extra respec then we do all files
+    if (filteredRespecPaths.length === 0) {
+        if (logalot) { console.log(`filteredRespecPaths is empty. doing allRespecPaths found (I: b98f54656899646025eecb4c028ab523)`); }
+        filteredRespecPaths = allRespecPaths.concat();
+    } else {
+        console.log(`filteredRespecPaths for extra respec: ${filteredRespecPaths} (I: b98f54656899646025eecb4c028ab523)`);
+        respecGib.extraRespecOnly = true;
+    }
+}
+
+// #endregion 1. get respec paths
+
+respecGib.allRespecPaths = allRespecPaths;
+respecGib.filteredRespecPaths = filteredRespecPaths;
+const respecPaths = filteredRespecPaths ?? allRespecPaths;
+respecGib.respecPaths = respecPaths;
+if (logalot) { console.log(`respecPaths found:\n${respecPaths}`); }
+
+// #region 2. execute paths' respective respecs
+
+// for now, we'll do sequentially, but in the future we could conceivable farm
+// these out to other node processes, or at least Promise.all
+
+for (let i = 0; i < respecPaths.length; i++) {
+    const respecPath = respecPaths[i];
+    if (logalot) { console.log(respecPath); }
+    const esm = await import(respecPath);
+    if (logalot) { console.log(pretty(Object.keys(esm))); }
+}
+
+const skippedRespecPathCount = respecGib.allRespecPaths.length - respecGib.respecPaths.length;
+if (skippedRespecPathCount > 0) {
+    console.log('');
+    console.error('\x1b[33m%s\x1b[0m', `${skippedRespecPathCount} respec files completely skipped.`);  // yellow
+}
+if (respecGib.ifWeBlocksSkipped > 0) {
+    console.log('');
+    console.error('\x1b[33m%s\x1b[0m', `${respecGib.ifWeBlocksSkipped} ifWe blocks ran but skipped reporting`);  // yellow
+}
+
+if (respecGib.errorMsgs.length === 0) {
+    console.log('');
+    console.error('\x1b[32m%s\x1b[0m', `💚💚 nothing but respec 💚💚`);  // green
+} else {
+    console.log('');
+    console.error('\x1b[31m%s\x1b[0m', `💔💔 DISrespec found 💔💔`);  // red
+    for (const errorMsg of respecGib.errorMsgs) {
+        console.error('\x1b[31m%s\x1b[0m', errorMsg);  // red
+    }
+}
+
+// #endregion 2. execute paths' respective respecs
+
+// #region helper functions
+
+/**
+ * builds a list of respec file paths, recursively traversing subdirectories
+ * starting from `dirPath`.
+ *
+ * @param dirPath a full path corresponding to a directory
+ * @param found respec paths already found (used in recursive calls)
+ * @returns list of all respec paths according to the respec regexp constant {@link RESPEC_FILE_REG_EXP}
+ */
+async function getRespecFileFullPaths(dirPath: string, found: string[]): Promise<string[]> {
+    const lc = `[${getRespecFileFullPaths.name}][${dirPath}]`;
+    try {
+        if (logalot) { console.log(`${lc} starting... (I: 16026290523925f79ba1933847e2a623)`); }
+        found ??= [];
+        const children = await readdir(dirPath);
+        if (logalot) { for (let i = 0; i < children.length; i++) { console.log(children[i]); } }
+        const files: string[] = [];
+        const dirs: string[] = [];
+        children.forEach(name => {
+            const fullPath = pathUtils.join(dirPath, name);
+            const stat = statSync(fullPath);
+            if (stat.isDirectory()) {
+                // symbolic link could create a loop
+                if (!stat.isSymbolicLink()) { dirs.push(fullPath); }
+            } else if (!!name.match(RESPEC_FILE_REG_EXP)) {
+                files.push(fullPath);
+            }
+        });
+
+        found = found.concat(files);
+        for (let i = 0; i < dirs.length; i++) {
+            const subfound = await getRespecFileFullPaths(dirs[i], found);
+            found = found.concat(subfound);
+        }
+        return Array.from(new Set(found)); // unique
+    } catch (error) {
+        console.error(`${lc} ${error.message}`);
+        throw error;
+    } finally {
+        if (logalot) { console.log(`${lc} complete.`); }
+    }
+}
+
+/**
+ * Searches through the file (without importing it) for extra respecful
+ * functions.
+ *
+ * @param respecPath
+ * @returns true if extra respecful functions found in file
+ */
+async function respecFileHasExtraRespec(respecPath: string): Promise<boolean> {
+    const lc = `[${respecFileHasExtraRespec.name}]`;
+    try {
+        if (logalot) { console.log(`${lc} starting... (I: 61f3221917ba77175efa305b14defc23)`); }
+        const file = await open(respecPath);
+        for await (const line of file.readLines()) {
+            const hasExtraRespecInLine =
+                EXTRA_RESPEC_FUNCTION_NAMES.some(fnName => {
+                    if (line.includes(`${fnName}(`)) { return true; }
+                });
+            if (hasExtraRespecInLine) {
+                return true;
+            }
+        }
+        return false;
+    } catch (error) {
+        console.error(`${lc} ${error.message}`);
+        throw error;
+    } finally {
+        if (logalot) { console.log(`${lc} complete.`); }
+    }
+}
+
+// #endregion helper functions

package/src/spec-helper.node.respec.mts

@@ -0,0 +1,45 @@
+import { default as pathUtils } from 'path';
+
+import { delay, getUUID, } from '@ibgib/helper-gib';
+
+/**
+ * helper function to get the filename for use in specs.
+ *
+ * @param importMetaUrl import.meta.url
+ * @returns currently executing filename
+ */
+export async function getCurrentFilename(importMetaUrl: string): Promise<string> {
+    const lc = `[${getCurrentFilename.name}]`;
+    try {
+        const pieces = importMetaUrl.split(pathUtils.sep);
+        let filename = pieces.at(-1)?.replace(/\.mjs$/, '')
+        if (!filename) {
+            console.warn(`filename not able to be gotten?`);
+            filename = (new Date()).toTimeString() + (await getUUID());
+        }
+        return `ibgib${pathUtils.sep}${filename}`;
+    } catch (error) {
+        console.error(`${lc} ${error.message}`);
+        throw error;
+    }
+}
+
+export async function specGetSpaceId(): Promise<string> {
+    await delay(10);
+    let uuid = await getUUID();
+    let now = new Date();
+    now.getMinutes();
+    let timeComponent = now.getMinutes().toString() + now.getSeconds().toString() + now.getMilliseconds().toString()
+    uuid = timeComponent + uuid.substring(timeComponent.length, uuid.length);
+    return uuid;
+}
+export function specGetSpaceName(uuid: string): string {
+    return uuid.substring(0, 12);
+}
+
+export function specGetSpaceDescription(uuid: string): string {
+    return 'description for ' + uuid.substring(0, 8);
+}
+export function specGetBaseSubPath(uuid: string): string {
+    return uuid.slice();
+}

package/src/witness/app/app-base-v1.mts

@@ -13,12 +13,14 @@ import { CommentIbGib_V1 } from '../../common/comment/comment-types.mjs';
 import { PicIbGib_V1 } from '../../common/pic/pic-types.mjs';
 import { ErrorIbGib_V1 } from '../../common/error/error-types.mjs';
 import { validateCommonAppData } from './app-helper.mjs';
-import { argy_, isArg, resulty_ } from '../witness-helper.mjs';
+import { argy_, isArg, isCommand, resulty_ } from '../witness-helper.mjs';
 import { IbGibLocalSpaceService_AllPowerful } from '../../core-types.mjs';
 import { pretty } from '@ibgib/helper-gib';
 import { GLOBAL_LOG_A_LOT } from '../../core-constants.mjs';
 import { errorIbGib } from '../../common/error/error-helper.mjs';
 import { getIbGibAddr } from '@ibgib/ts-gib';
+import { isComment } from '../../common/comment/comment-helper.mjs';
+import { isPic } from '../../common/pic/pic-helper.mjs';
 
 const logalot = GLOBAL_LOG_A_LOT || false;
 
@@ -54,18 +56,6 @@ export abstract class AppBase_V1<
      * Log context for convenience with logging. (Ignore if you don't want to use this.)
      */
     protected lc: string = `[${AppBase_V1.name}]`;
-    // protected lc: string = `[${AppBase_V1.name}]`;
-
-    // getAppIb(classname: string): string {
-    //     const lc = `${this.lc}[${this.getAppIb.name}]`;
-    //     if (!classname) {
-    //         classname = this.lc?.replace('[','').replace(']','') || AppBase_V1.name+'_descendant';
-    //         console.warn(`${lc} classname is falsy. Using ${classname}.`);
-    //     }
-    //     const name = this.data?.name || IBGIB_SPACE_NAME_DEFAULT;
-    //     const id = this.data?.uuid || undefined;
-    //     return `witness space ${classname} ${name} ${id}`;
-    // }
 
     /**
      * Reference to the local ibgibs service, which is one way at getting at the
@@ -90,22 +80,42 @@ export abstract class AppBase_V1<
         try {
             if (logalot) { console.log(`${lc} starting...`); }
 
+
+            await this.loadNewerSelfIfAvailable();
+
+            let result = await this.routeAndDoArg({ arg });
+            if (!result) { result = await this.doDefault({ ibGib: arg }); }
+            if (!result) { console.warn(`${lc} result falsy...Could not produce result? Was doDefault implemented in concrete class? (W: 15e70486bc33922f9388961bab815223)`); }
+            return result;
+        } catch (error) {
+            console.error(`${lc} ${error.message}`);
+            throw error;
+        } finally {
+            if (logalot) { console.log(`${lc} complete.`); }
+        }
+    }
+
+    protected async loadNewerSelfIfAvailable(): Promise<void> {
+        const lc = `${this.lc}[${this.loadNewerSelfIfAvailable.name}]`;
+        try {
+            if (logalot) { console.log(`${lc} starting... (I: 94755c3131f4dfa12d20fa38e2926522)`); }
             if (this.ibgibsSvc) {
                 // check for newer version of self locally before executing
-                const appAddr = getIbGibAddr({ ibGib: this });
-                const latestAddr = await this.ibgibsSvc.getLatestAddr({ ibGib: this });
-                if (latestAddr && latestAddr !== appAddr) {
-                    // app has a newer ibgib in its timeline
-                    let resGet = await this.ibgibsSvc.get({ addr: latestAddr });
+                const thisAddr = getIbGibAddr({ ibGib: this });
+                const thisLatestAddr = await this.ibgibsSvc.getLatestAddr({ ibGib: this });
+                if (thisLatestAddr && thisLatestAddr !== thisAddr) {
+                    // witness has a newer ibgib in its timeline
+                    let resGet = await this.ibgibsSvc.get({ addr: thisLatestAddr });
                     if (!resGet || !resGet?.success || (resGet?.ibGibs ?? []).length === 0) {
-                        throw new Error(`could not get newer app ibgib (E: 15fa346c8ac17edb96e4b0870104c122)`);
+                        throw new Error(`could not get latest this ibgib in timeline? (E: 15fa346c8ac17edb96e4b0870104c122)`);
                     }
                     await this.loadIbGibDto(resGet.ibGibs![0] as IbGib_V1<TData, TRel8ns>);
                     const validationErrors = await this.validateThis();
                     if (validationErrors?.length > 0) { throw new Error(`validationErrors when loading newer version: ${pretty(validationErrors)} (E: 0d9f0684a1ff6af44e20a57130e3ac22)`); }
                 }
+            } else {
+                console.warn(`${lc} this.ibgibsSvc undefined (W: 44cc5bf1b14b4695b8de4c589787be06)`);
             }
-            return this.routeAndDoArg({ arg });
         } catch (error) {
             console.error(`${lc} ${error.message}`);
             throw error;
@@ -138,11 +148,16 @@ export abstract class AppBase_V1<
         const lc = `${this.lc}[${this.routeAndDoArg.name}]`;
         try {
             if (logalot) { console.log(`${lc} starting...`); }
-            if (isArg({ ibGib: arg as IbGib_V1 })) {
-                if ((arg.data as any).cmd) {
+            const ibGib = arg as IbGib_V1;
+            if (isArg({ ibGib })) {
+                if (isCommand({ ibGib })) {
                     return this.doCmdArg({ arg: arg as AppCmdIbGib<IbGib_V1, AppCmdData, AppCmdRel8ns> });
+                } else if (isComment({ ibGib })) {
+                    return this.doComment({ ibGib: ibGib as CommentIbGib_V1 });
+                } else if (isPic({ ibGib })) {
+                    return this.doPic({ ibGib: ibGib as PicIbGib_V1 });
                 } else {
-                    return this.doDefault({ ibGib: arg });
+                    return undefined;
                 }
             }
         } catch (error) {

package/src/witness/app/app-constants.mts

@@ -14,3 +14,6 @@ export const MENU_ITEM_IB_SUBSTRING_LENGTH = 20;
 
 export const QUERY_PARAM_PAUSED = 'paused';
 export const QUERY_PARAM_ROBBOT = 'robbot';
+
+export const APP_NAME_REGEXP = /^[a-zA-Z0-9_\-.]{1,32}$/;
+export const APP_REL8N_NAME = 'app';

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

@@ -3,8 +3,9 @@ import { Gib, Ib, } from '@ibgib/ts-gib';
 import { validateIbGibIntrinsically } from '@ibgib/ts-gib/dist/V1/validate-helper.mjs';
 
 
-import { APP_NAME_REGEXP, APP_REL8N_NAME, GLOBAL_LOG_A_LOT } from '../../core-constants.mjs';
+import { GLOBAL_LOG_A_LOT } from '../../core-constants.mjs';
 import { AppData_V1, } from './app-types.mjs';
+import { APP_NAME_REGEXP, APP_REL8N_NAME, } from './app-constants.mjs';
 import { IbGibAppAny } from './app-base-v1.mjs';
 // import { CommonService } from '../../services/common.service.mjs';
 // import { getFn_promptAppIbGib } from './prompt-functions.mjs';

package/src/witness/robbot/robbot-base-v1.mts

@@ -26,7 +26,7 @@ import { CommentIbGib_V1 } from '../../common/comment/comment-types.mjs';
 import { PicIbGib_V1 } from '../../common/pic/pic-types.mjs';
 import { getInteractionIbGib_V1, validateCommonRobbotData } from './robbot-helper.mjs';
 import { argy_, isArg, resulty_ } from '../witness-helper.mjs';
-import { IbGibLocalSpaceService_AllPowerful as IbgibsService } from '../../core-types.mjs';
+import { IbGibLocalSpaceService_AllPowerful } from '../../core-types.mjs';
 import { validateIbGibIntrinsically } from '@ibgib/ts-gib/dist/V1/validate-helper.mjs';
 import { ErrorIbGib_V1 } from '../../common/error/error-types.mjs';
 import { Lex, clone, delay, getTimestamp, getUUID, pretty } from '@ibgib/helper-gib';
@@ -115,7 +115,7 @@ export abstract class RobbotBase_V1<
      * Reference to the local ibgibs service, which is one way at getting at the
      * local user space.
      */
-    public ibgibsSvc: IbgibsService | undefined;
+    public ibgibsSvc: IbGibLocalSpaceService_AllPowerful | undefined;
 
     /**
      * When the robbot has to get some ibgibs, might as well store them here so
@@ -195,7 +195,7 @@ export abstract class RobbotBase_V1<
      * the single `witness` access point, but of course these runtime aspects
      * won't be memoized if storing the ibgib.
      */
-    public initialized: Promise<void>;
+    // public initialized: Promise<void>;
 
     constructor(initialData?: TData, initialRel8ns?: TRel8ns) {
         super(initialData, initialRel8ns);
@@ -331,7 +331,10 @@ export abstract class RobbotBase_V1<
 
             await this.loadNewerSelfIfAvailable();
 
-            return this.routeAndDoArg({ arg });
+            let result = await this.routeAndDoArg({ arg });
+            if (!result) { result = await this.doDefault({ ibGib: arg }); }
+            if (!result) { console.warn(`${lc} result falsy...Could not produce result? Was doDefault implemented in concrete class? (W: 67f5fc5e6e864a13b0053fb54cfba100)`); }
+            return result;
         } catch (error) {
             console.error(`${lc} ${error.message}`);
             throw error;
@@ -639,7 +642,7 @@ export abstract class RobbotBase_V1<
         /**
          * If provided, will register the newly created ibgib.
          */
-        ibgibsSvc?: IbgibsService,
+        ibgibsSvc?: IbGibLocalSpaceService_AllPowerful,
         // /**
         //  * If given (which atow is most likely the case), then the {@link TransformResult} will
         //  * be persisted in this `space`.
@@ -882,7 +885,7 @@ export abstract class RobbotBase_V1<
     }: {
         text: string,
         contextIbGib: IbGib_V1,
-        ibgibsSvc?: IbgibsService,
+        ibgibsSvc?: IbGibLocalSpaceService_AllPowerful,
     }): Promise<void> {
         const lc = `${this.lc}[${this.createCommentAndRel8ToContextIbGib.name}]`;
         try {