@ibgib/vcs-gib 0.0.30 → 0.0.33

package/src/cli/commands/cli-add-cmd.mts

@@ -0,0 +1,65 @@
+/**
+ * @module add-cmd
+ *
+ * CLI command handler for `vcs add <path...>`.
+ * Bootstraps workspace projection space and delegates to executeVcsAdd.
+ */
+
+import path from 'node:path';
+
+import { extractErrorMsg } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+import { openVcsRepository } from '../vcs-repo-helper.mjs';
+import { GLOBAL_LOG_A_LOT } from '../../vcs-gib-constants.mjs';
+
+const lcFile = `[add-cmd]`;
+const logalot = GLOBAL_LOG_A_LOT;
+
+export interface AddCmdOpts {
+    paths?: string[];
+    targetDir?: string;
+    vcsFolderName?: string;
+    all?: boolean;
+    quiet?: boolean;
+}
+
+export interface AddCmdResult {
+    stagedPaths: string[];
+    stagedCount: number;
+}
+
+export async function executeAddCmd({
+    paths = [],
+    targetDir = process.cwd(),
+    vcsFolderName = '.vcsgib',
+    all = false,
+    quiet = false,
+}: AddCmdOpts = {}): Promise<AddCmdResult> {
+    const lc = `${lcFile}[${executeAddCmd.name}]`;
+    try {
+        if (logalot) { console.log(`${lc} starting... (I: genuuid)`); }
+
+        const absTargetDir = path.resolve(targetDir);
+        const { repo } = await openVcsRepository({ targetDir: absTargetDir, vcsFolderName });
+
+        const addRes = await repo.add(paths, {
+            all,
+            targetDir: absTargetDir,
+        });
+
+        if (!quiet) {
+            for (const stagedPath of addRes.stagedPaths) {
+                console.log(`staged: ${stagedPath}`);
+            }
+        }
+
+        return {
+            stagedPaths: addRes.stagedPaths,
+            stagedCount: addRes.stagedCount,
+        };
+    } catch (error) {
+        console.error(`${lc} ${extractErrorMsg(error)} (E: genuuid)`);
+        throw error;
+    } finally {
+        if (logalot) { console.log(`${lc} complete. (I: genuuid)`); }
+    }
+}

package/src/cli/commands/cli-branch-cmd.mts

@@ -0,0 +1,87 @@
+/**
+ * @module branch-cmd
+ *
+ * CLI command handler for `vcs branch [branchName]`.
+ * Delegates to executeVcsBranch and formats terminal output.
+ */
+
+import path from 'node:path';
+
+import { extractErrorMsg } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+import { openVcsRepository } from '../vcs-repo-helper.mjs';
+import { GLOBAL_LOG_A_LOT } from '../../vcs-gib-constants.mjs';
+
+const lcFile = `[branch-cmd]`;
+const logalot = GLOBAL_LOG_A_LOT;
+
+export interface BranchInfo {
+    name: string;
+    isActive: boolean;
+    addr: string;
+    rootItemAddr?: string;
+}
+
+export interface BranchCmdOpts {
+    branchName?: string;
+    itemPath?: string;
+    targetDir?: string;
+    vcsFolderName?: string;
+    quiet?: boolean;
+}
+
+export interface BranchCmdResult {
+    branches: BranchInfo[];
+    createdBranchName?: string;
+    createdBranchAddr?: string;
+}
+
+export async function executeBranchCmd({
+    branchName,
+    itemPath,
+    targetDir = process.cwd(),
+    vcsFolderName = '.vcsgib',
+    quiet = false,
+}: BranchCmdOpts = {}): Promise<BranchCmdResult> {
+    const lc = `${lcFile}[${executeBranchCmd.name}]`;
+    try {
+        if (logalot) { console.log(`${lc} starting... (I: genuuid)`); }
+
+        const absTargetDir = path.resolve(targetDir);
+        const { repo, } = await openVcsRepository({ targetDir: absTargetDir, vcsFolderName });
+
+        const branchRes = await repo.branch({
+            branchName,
+            itemPath,
+            targetDir: absTargetDir,
+        });
+
+        const branches: BranchInfo[] = branchRes.branches.map(b => ({
+            name: b.name,
+            isActive: b.isActive,
+            addr: b.branchAddr || '',
+            rootItemAddr: b.rootItemAddr,
+        }));
+
+        if (!quiet) {
+            if (!branchName) {
+                for (const b of branches) {
+                    const prefix = b.isActive ? '* ' : '  ';
+                    console.log(`${prefix}${b.name}`);
+                }
+            } else {
+                console.log(`Created branch '${branchRes.createdBranchName}'`);
+            }
+        }
+
+        return {
+            branches,
+            createdBranchName: branchRes.createdBranchName,
+            createdBranchAddr: branchRes.createdBranchAddr,
+        };
+    } catch (error) {
+        console.error(`${lc} ${extractErrorMsg(error)} (E: genuuid)`);
+        throw error;
+    } finally {
+        if (logalot) { console.log(`${lc} complete. (I: genuuid)`); }
+    }
+}

package/src/cli/commands/cli-checkout-cmd.mts

@@ -0,0 +1,72 @@
+/**
+ * @module checkout-cmd
+ *
+ * CLI command handler for `vcs checkout <branchName>`.
+ * Thin facade delegating to VcsRepository.checkout.
+ */
+
+import path from 'node:path';
+
+import { extractErrorMsg } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+import { openVcsRepository } from '../vcs-repo-helper.mjs';
+import { GLOBAL_LOG_A_LOT } from '../../vcs-gib-constants.mjs';
+
+const lcFile = `[checkout-cmd]`;
+const logalot = GLOBAL_LOG_A_LOT;
+
+export interface CheckoutCmdOpts {
+    branchName?: string;
+    force?: boolean;
+    targetDir?: string;
+    vcsFolderName?: string;
+    quiet?: boolean;
+}
+
+export interface CheckoutCmdResult {
+    previousBranch: string;
+    currentBranch: string;
+    worktreePath: string;
+}
+
+export async function executeCheckoutCmd({
+    branchName,
+    force = false,
+    targetDir = process.cwd(),
+    vcsFolderName = '.vcsgib',
+    quiet = false,
+}: CheckoutCmdOpts = {}): Promise<CheckoutCmdResult> {
+    const lc = `${lcFile}[${executeCheckoutCmd.name}]`;
+    try {
+        if (logalot) { console.log(`${lc} starting... (I: genuuid)`); }
+
+        const trimmedBranchName = branchName?.trim();
+        if (!trimmedBranchName) {
+            throw new Error(`Branch name is required for checkout (E: genuuid)`);
+        }
+
+        const absTargetDir = path.resolve(targetDir);
+        const { repo } = await openVcsRepository({ targetDir: absTargetDir, vcsFolderName });
+
+        const checkoutRes = await repo.checkout({
+            branchName: trimmedBranchName,
+            force,
+            targetDir: absTargetDir,
+        });
+
+        if (!quiet) {
+            console.log(`Switched to branch '${checkoutRes.currentBranch}' (I: genuuid)`);
+            console.log(`Worktree path: ${checkoutRes.worktreePath}`);
+        }
+
+        return {
+            previousBranch: checkoutRes.previousBranch,
+            currentBranch: checkoutRes.currentBranch,
+            worktreePath: checkoutRes.worktreePath,
+        };
+    } catch (error) {
+        console.error(`${lc} ${extractErrorMsg(error)} (E: genuuid)`);
+        throw error;
+    } finally {
+        if (logalot) { console.log(`${lc} complete. (I: genuuid)`); }
+    }
+}

package/src/cli/commands/cli-commit-cmd.mts

@@ -0,0 +1,77 @@
+/**
+ * @module commit-cmd
+ *
+ * CLI command handler for `vcs commit -m <message>`.
+ * Bootstraps workspace projection space and delegates to executeVcsCommit.
+ */
+
+import path from 'node:path';
+
+import { extractErrorMsg } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+
+import { GLOBAL_LOG_A_LOT } from '../../vcs-gib-constants.mjs';
+import { openVcsRepository } from '../vcs-repo-helper.mjs';
+
+const lcFile = `[commit-cmd]`;
+const logalot = GLOBAL_LOG_A_LOT;
+
+export interface CommitCmdOpts {
+    message?: string;
+    targetDir?: string;
+    vcsFolderName?: string;
+    author?: string;
+    quiet?: boolean;
+}
+
+export interface CommitCmdResult {
+    branchName: string;
+    commitAddr: string;
+    commentAddr?: string;
+    rootItemAddr: string;
+    committedPaths: string[];
+    ingestedCommentsCount: number;
+}
+
+export async function executeCommitCmd({
+    message,
+    targetDir = process.cwd(),
+    vcsFolderName = '.vcsgib',
+    author = 'vcs-user',
+    quiet = false,
+}: CommitCmdOpts = {}): Promise<CommitCmdResult> {
+    const lc = `${lcFile}[${executeCommitCmd.name}]`;
+    try {
+        if (logalot) { console.log(`${lc} starting... (I: genuuid)`); }
+
+        const absTargetDir = path.resolve(targetDir);
+        const { repo } = await openVcsRepository({ targetDir: absTargetDir, vcsFolderName });
+
+        const commitRes = await repo.commit({
+            message,
+            author,
+            targetDir: absTargetDir,
+        });
+
+        if (!quiet) {
+            console.log(`[${commitRes.branchName} ${commitRes.commitAddr.slice(0, 7)}] ${message || '(companion comments committed)'}`);
+            console.log(` ${commitRes.committedPaths.length} file(s) changed`);
+            if (commitRes.ingestedCommentsCount > 0) {
+                console.log(` ${commitRes.ingestedCommentsCount} companion comment(s) attached and merged`);
+            }
+        }
+
+        return {
+            branchName: commitRes.branchName,
+            commitAddr: commitRes.commitAddr,
+            commentAddr: commitRes.commentAddr,
+            rootItemAddr: commitRes.rootItemAddr,
+            committedPaths: commitRes.committedPaths,
+            ingestedCommentsCount: commitRes.ingestedCommentsCount,
+        };
+    } catch (error) {
+        console.error(`${lc} ${extractErrorMsg(error)} (E: 4c453a4e7648a5f6058edf489254c826)`);
+        throw error;
+    } finally {
+        if (logalot) { console.log(`${lc} complete. (I: genuuid)`); }
+    }
+}

package/src/cli/commands/{generate-comment-cmd.mts → cli-generate-comment-cmd.mts}

@@ -1,6 +1,6 @@
 /**
  * @module generate-comment-cmd
- * 
+ *
  * Command handler for `vcs generate-comment` (synonyms: `gen-comment`, `gen-msg`, `gcomm`, `gmsg`).
  * Scans repository status or target paths and creates `.ib.<file>.md` or `.ib.<topic>.md` companion metadata files.
  */
@@ -11,7 +11,9 @@ import fs from 'node:fs/promises';
 import { extractErrorMsg } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
 import { bootstrapVcsMetaspace } from '../../bootstrap/node-bootstrap.mjs';
 import { GLOBAL_LOG_A_LOT } from '../../vcs-gib-constants.mjs';
-import { getRepoStatus } from '../../engine/status/status-helper.mjs';
+import { getRepoStatus } from '@ibgib/core-gib/dist/vcs/status/status-helper.mjs';
+import { getB2tFSIndexIbGib } from '@ibgib/core-gib/dist/vcs/index/index-helper.mjs';
+import { readVcsIndexProjectionFromDisk } from '../vcs-projection-helper.mjs';
 
 const lcFile = `[generate-comment-cmd]`;
 const logalot = GLOBAL_LOG_A_LOT;
@@ -40,7 +42,7 @@ export async function executeGenerateCommentCmd({
 
     try {
         if (logalot) {
-            console.log(`${lc} starting executeGenerateCommentCmd (I: 8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e)`);
+            console.log(`${lc} starting... (I: genuuid)`);
         }
 
         const absTargetDir = path.resolve(targetDir);
@@ -54,12 +56,16 @@ export async function executeGenerateCommentCmd({
         try {
             await fs.access(vcsPath);
         } catch {
-            throw new Error(`Not an ibgib repository (directory ${vcsPath} does not exist) (E: 9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e4f)`);
+            throw new Error(`Not an ibgib repository (directory ${vcsPath} does not exist) (E: genuuid)`);
         }
 
+        const indexIbGib = (await getB2tFSIndexIbGib({ space: localSpace, metaspace }))
+            || (await readVcsIndexProjectionFromDisk({ vcsPath, space: localSpace }));
+
         const statusRes = await getRepoStatus({
             metaspace,
             localSpace,
+            indexIbGib,
             vcsPath,
             repoRoot,
             vcsFolderName,
@@ -161,11 +167,11 @@ export async function executeGenerateCommentCmd({
             skippedFiles,
         };
     } catch (error) {
-        console.error(`${lc} ${extractErrorMsg(error)} (E: 0d1e2f3a4b5c6d7e8f9a0b1c2d3e4f5a)`);
+        console.error(`${lc} ${extractErrorMsg(error)} (E: genuuid)`);
         throw error;
     } finally {
         if (logalot) {
-            console.log(`${lc} complete. (I: 1e2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b)`);
+            console.log(`${lc} complete. (I: genuuid)`);
         }
     }
 }

package/src/cli/commands/cli-init-cmd.mts

@@ -0,0 +1,78 @@
+/**
+ * @module init-cmd
+ *
+ * CLI command handler for `vcs init [targetDir]`.
+ * Bootstraps Node environment, creates disk directories, and delegates to executeVcsInit.
+ */
+
+import path from 'node:path';
+import fs from 'node:fs/promises';
+
+import { extractErrorMsg } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+import { VcsRepository } from '@ibgib/core-gib/dist/vcs/vcs-repository.mjs';
+import { B2TFS_BRANCH_DEFAULT_NAME } from '@ibgib/core-gib/dist/vcs/branch/branch-constants.mjs';
+
+import { GLOBAL_LOG_A_LOT } from '../../vcs-gib-constants.mjs';
+import { bootstrapVcsMetaspace } from '../../bootstrap/node-bootstrap.mjs';
+import { writeVcsIndexProjectionToDisk } from '../vcs-projection-helper.mjs';
+
+const lcFile = `[init-cmd]`;
+const logalot = GLOBAL_LOG_A_LOT;
+
+export interface InitCmdOpts {
+    targetDir?: string;
+    vcsFolderName?: string;
+    defaultBranchName?: string;
+    quiet?: boolean;
+}
+
+export interface InitCmdResult {
+    vcsPath: string;
+    spaceId: string;
+    branchName: string;
+    rootItemIb: string;
+}
+
+export async function executeInitCmd({
+    targetDir = process.cwd(),
+    vcsFolderName = '.vcsgib',
+    defaultBranchName = B2TFS_BRANCH_DEFAULT_NAME,
+    quiet = false,
+}: InitCmdOpts = {}): Promise<InitCmdResult> {
+    const absTargetDir = path.resolve(targetDir);
+    const vcsPath = path.join(absTargetDir, vcsFolderName);
+
+    // 1. Ensure target directory exists
+    await fs.mkdir(absTargetDir, { recursive: true });
+
+    // 2. Bootstrap Metaspace and localSpace (creates .vcsgib on disk)
+    const { metaspace, localSpace } = await bootstrapVcsMetaspace({
+        repoPath: absTargetDir,
+        vcsFolderName,
+        defaultSpaceName: `vcs_${path.basename(absTargetDir).replace(/[^a-zA-Z0-9_\-]/g, '_')}`,
+    });
+
+    // 3. Facade instantiation and domain init
+    const repo = new VcsRepository({
+        metaspace,
+        localSpace,
+        repoRoot: absTargetDir,
+        vcsFolderName,
+    });
+
+    const initRes = await repo.init({
+        rootFolderName: path.basename(absTargetDir) || 'root',
+        branchName: defaultBranchName,
+    });
+
+    if (!quiet) {
+        console.log(`Initialized empty ibgib repository in ${vcsPath} (branch: ${defaultBranchName})`);
+    }
+
+    return {
+        vcsPath,
+        spaceId: initRes.spaceId,
+        branchName: initRes.branchName,
+        rootItemIb: initRes.rootItem.ib,
+    };
+}

package/src/cli/commands/cli-log-cmd.mts

@@ -0,0 +1,126 @@
+/**
+ * @module log-cmd
+ *
+ * CLI command handler for `vcs log`.
+ * Delegates to executeVcsLog and formats console output.
+ */
+
+import path from 'node:path';
+import fs from 'node:fs/promises';
+
+import { extractErrorMsg } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+// import { getSpaceIdFromIb } from '@ibgib/core-gib/dist/witness/space/metaspace/metaspace-innerspace/metaspace-innerspace-helper.mjs';
+
+import { GLOBAL_LOG_A_LOT } from '../../vcs-gib-constants.mjs';
+import { openVcsRepository } from '../vcs-repo-helper.mjs';
+
+const lcFile = `[log-cmd]`;
+const logalot = GLOBAL_LOG_A_LOT;
+
+export interface VcsLogItem {
+    branchAddr?: string;
+    commitAddr: string;
+    commentAddr?: string;
+    message: string;
+    timestamp: string;
+    author: string;
+    rootItemAddr?: string;
+    committedPaths?: string[];
+    itemComments?: Array<{ path: string; name?: string; message: string }>;
+}
+
+export interface LogCmdOpts {
+    targetDir?: string;
+    vcsFolderName?: string;
+    filePath?: string;
+    allComments?: boolean;
+    quiet?: boolean;
+}
+
+export interface LogCmdResult {
+    branchName: string;
+    targetPath?: string;
+    commits: VcsLogItem[];
+}
+
+export async function executeLogCmd({
+    targetDir = process.cwd(),
+    vcsFolderName = '.vcsgib',
+    filePath,
+    allComments = false,
+    quiet = false,
+}: LogCmdOpts = {}): Promise<LogCmdResult> {
+    const lc = `${lcFile}[${executeLogCmd.name}]`;
+
+    try {
+        if (logalot) {
+            console.log(`${lc} starting executeLogCmd (I: genuuid)`);
+        }
+
+        const absTargetDir = path.resolve(targetDir);
+        const { repo } = await openVcsRepository({ targetDir: absTargetDir, vcsFolderName });
+        const indexIbGib = await repo.getIndexIbGib();
+        const activeBranchSpace = await repo.getActiveBranchSpace(indexIbGib);
+
+        const logRes = await repo.log({
+            activeBranchSpace,
+            indexIbGib,
+            // repoRoot, // need this? we need jsdocs on wth repoRoot is
+            filePath,
+            allComments,
+            targetDir: absTargetDir,
+        });
+
+        const commits: VcsLogItem[] = logRes.commits;
+
+        if (!quiet) {
+            if (logRes.targetPath) {
+                console.log(`File: ${logRes.targetPath} (branch: ${logRes.branchName}) (I: genuuid)`);
+                if (commits.length === 0) {
+                    console.log('No comments found for this file.');
+                } else {
+                    for (const commit of commits) {
+                        console.log(`\nitem ${commit.commitAddr}`);
+                        if (commit.timestamp) { console.log(`Date:   ${commit.timestamp}`); }
+                        console.log(`\n    ${commit.message}\n`);
+                    }
+                }
+            } else {
+                console.log(`Branch: ${logRes.branchName} (I: genuuid)`);
+                if (commits.length === 0) {
+                    console.log('No commits yet.');
+                } else {
+                    for (const commit of commits) {
+                        console.log(`\ncommit ${commit.commitAddr}`);
+                        console.log(`Author: ${commit.author}`);
+                        console.log(`Date:   ${commit.timestamp}`);
+                        console.log(`\n    ${commit.message}\n`);
+                        if (commit.committedPaths && commit.committedPaths.length > 0) {
+                            console.log(`Changed: ${commit.committedPaths.join(', ')}`);
+                        }
+                        if (commit.itemComments && commit.itemComments.length > 0) {
+                            console.log('Item Comments:');
+                            for (const ic of commit.itemComments) {
+                                const label = ic.name ? `${ic.path} (${ic.name})` : ic.path;
+                                console.log(`  * [${label}]: ${ic.message}`);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        return {
+            branchName: logRes.branchName,
+            targetPath: logRes.targetPath,
+            commits,
+        };
+    } catch (error) {
+        console.error(`${lc} ${extractErrorMsg(error)} (E: genuuid)`);
+        throw error;
+    } finally {
+        if (logalot) {
+            console.log(`${lc} complete. (I: genuuid)`);
+        }
+    }
+}

package/src/cli/commands/cli-merge-cmd.mts

@@ -0,0 +1,99 @@
+/**
+ * @module merge-cmd
+ *
+ * CLI command handler for `vcs merge <branchName>`.
+ * Merges incoming branch into base branch and delegates to executeVcsMerge.
+ */
+
+import path from 'node:path';
+
+import { extractErrorMsg } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+import { getOrCreateBranchSpace } from '@ibgib/core-gib/dist/vcs/branch/branch-helper.mjs';
+import { getSpaceIdFromIb } from '@ibgib/core-gib/dist/witness/space/metaspace/metaspace-innerspace/metaspace-innerspace-helper.mjs';
+
+import { GLOBAL_LOG_A_LOT } from '../../vcs-gib-constants.mjs';
+import { openVcsRepository } from '../vcs-repo-helper.mjs';
+
+const lcFile = `[merge-cmd]`;
+const logalot = GLOBAL_LOG_A_LOT;
+
+export interface MergeCmdOpts {
+    incomingBranchName?: string;
+    targetDir?: string;
+    vcsFolderName?: string;
+    quiet?: boolean;
+}
+
+export interface MergeCmdResult {
+    baseBranch: string;
+    incomingBranch: string;
+    baseSpaceId: string;
+    incomingSpaceId: string;
+    mergedBranchAddr?: string;
+    worktreePath: string;
+}
+
+export async function executeMergeCmd({
+    incomingBranchName,
+    targetDir = process.cwd(),
+    vcsFolderName = '.vcsgib',
+    quiet = false,
+}: MergeCmdOpts = {}): Promise<MergeCmdResult> {
+    const lc = `${lcFile}[${executeMergeCmd.name}]`;
+    try {
+        if (logalot) {
+            console.log(`${lc} starting... (I: genuuid)`);
+        }
+
+        const trimmedIncomingBranchName = incomingBranchName?.trim();
+        if (!trimmedIncomingBranchName) {
+            throw new Error(`Branch name is required for merge (E: genuuid)`);
+        }
+
+        const absTargetDir = path.resolve(targetDir);
+        const { repo, vcsPath, activeWorktreeDir } =
+            await openVcsRepository({ targetDir: absTargetDir, vcsFolderName });
+
+        // todo: get baseBranchName based off of targetDir?
+        const baseBranchName = await repo.getActiveBranchName();
+
+        const incomingSpaceRes = await getOrCreateBranchSpace({
+            metaspace: repo.metaspace,
+            branchName: trimmedIncomingBranchName,
+        });
+
+        const activeBranchSpace = await repo.getActiveBranchSpace();
+        const activeBranchSpaceId = getSpaceIdFromIb(activeBranchSpace.ib);
+
+        const mergeRes = await repo.merge({
+            baseBranchSpace: activeBranchSpace, // what should this be? always the active one? Or does the working dir determine it? What is absTargetDir?
+            // message,
+            // repoRoot,
+            incomingBranchName: trimmedIncomingBranchName,
+            incomingBranchSpace: incomingSpaceRes.space,
+            targetDir: absTargetDir,
+        });
+
+        if (!quiet) {
+            console.log(`Successfully merged branch '${trimmedIncomingBranchName}' into '${baseBranchName}' (I: genuuid)`);
+            console.log(`  Worktree projection: ${activeWorktreeDir}`);
+        }
+
+
+        return {
+            baseBranch: mergeRes.baseBranch,
+            incomingBranch: mergeRes.incomingBranch,
+            baseSpaceId: activeBranchSpaceId,
+            incomingSpaceId: incomingSpaceRes.spaceId,
+            mergedBranchAddr: mergeRes.mergeCommitAddr,
+            worktreePath: activeWorktreeDir,
+        };
+    } catch (error) {
+        console.error(`${lc} ${extractErrorMsg(error)} (E: genuuid)`);
+        throw error;
+    } finally {
+        if (logalot) {
+            console.log(`${lc} complete. (I: genuuid)`);
+        }
+    }
+}