@ibgib/vcs-gib 0.0.6

package/src/cli/vcs-cli-main.mts

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+/**
+ * @module vcs-cli-main
+ * 
+ * Executable CLI entry point for the `vcs` command line interface.
+ * Parses command line arguments and dispatches execution to subcommand handlers.
+ */
+
+import { extractErrorMsg } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+
+import { parseVcsArgs } from './cli-arg-parser.mjs';
+import { VCS_SUBCOMMANDS } from './cli-constants.mjs';
+import { executeInitCmd } from './commands/init-cmd.mjs';
+import { executeStatusCmd } from './commands/status-cmd.mjs';
+import { executeAddCmd } from './commands/add-cmd.mjs';
+import { executeCommitCmd } from './commands/commit-cmd.mjs';
+import { executeLogCmd } from './commands/log-cmd.mjs';
+import { executeBranchCmd } from './commands/branch-cmd.mjs';
+import { executeCheckoutCmd } from './commands/checkout-cmd.mjs';
+import { AUTO_GENERATED_VERSION } from '../AUTO-GENERATED-version.mjs';
+import { GLOBAL_LOG_A_LOT } from '../vcs-gib-constants.mjs';
+
+const lcFile = `[vcs-cli-main]`;
+const logalot = GLOBAL_LOG_A_LOT;
+
+export interface MainOptions {
+    argv?: string[];
+}
+
+export function showHelp(): void {
+    const helpText = `
+vcs - Decentralized Version Control System (ibgib)
+
+Usage:
+  vcs <command> [options] [arguments]
+
+Commands:
+  init [dir]            Initialize a new ibgib repository
+  status                Show repository working tree status
+  add <path...>         Stage file/folder changes (-a, --all to stage all)
+  commit -m "message"   Record snapshot changes to the repository
+  log                   Show commit logs
+  branch [name]         List or create branches
+  checkout <branch>     Switch to a specified branch and project worktree
+
+Flags:
+  -h, --help            Show help information
+  -v, --version         Show version information
+  -m <message>          Commit message
+  -b <branch>           Target branch name
+  -a, --all             Stage all tracked/untracked files (for add)
+  -f, --force           Force operation execution
+`;
+    console.log(helpText.trim());
+}
+
+export function showVersion(): void {
+    console.log(`@ibgib/vcs-gib v${AUTO_GENERATED_VERSION}`);
+}
+
+export async function main({
+    argv = process.argv.slice(2),
+}: MainOptions = {}): Promise<number> {
+    const lc = `${lcFile}[${main.name}]`;
+    try {
+        if (logalot) {
+            console.log(`${lc} starting... (I: 4a5b6c7d8e9f0a1b2c3d4e5f6a7b8c9d)`);
+        }
+
+        const parsed = parseVcsArgs(argv);
+
+        if (parsed.flags.help) {
+            showHelp();
+            return 0;
+        }
+
+        switch (parsed.command) {
+            case VCS_SUBCOMMANDS.INIT: {
+                const targetDir = parsed.positionals[0] || process.cwd();
+                await executeInitCmd({ targetDir });
+                break;
+            }
+            case VCS_SUBCOMMANDS.STATUS: {
+                const targetDir = parsed.positionals[0] || process.cwd();
+                await executeStatusCmd({ targetDir });
+                break;
+            }
+            case VCS_SUBCOMMANDS.ADD: {
+                await executeAddCmd({
+                    paths: parsed.positionals,
+                    all: parsed.flags.all,
+                });
+                break;
+            }
+            case VCS_SUBCOMMANDS.COMMIT: {
+                await executeCommitCmd({
+                    message: parsed.flags.message,
+                });
+                break;
+            }
+            case VCS_SUBCOMMANDS.LOG: {
+                const targetDir = parsed.positionals[0] || process.cwd();
+                await executeLogCmd({ targetDir });
+                break;
+            }
+            case VCS_SUBCOMMANDS.BRANCH: {
+                const branchName = parsed.positionals[0] || parsed.flags.branchName;
+                await executeBranchCmd({ branchName });
+                break;
+            }
+            case VCS_SUBCOMMANDS.CHECKOUT: {
+                const branchName = parsed.positionals[0] || parsed.flags.branchName;
+                await executeCheckoutCmd({ branchName });
+                break;
+            }
+            case VCS_SUBCOMMANDS.VERSION: {
+                showVersion();
+                break;
+            }
+            case VCS_SUBCOMMANDS.HELP:
+            default: {
+                showHelp();
+                break;
+            }
+        }
+
+        return 0;
+    } catch (error) {
+        console.error(`Error: ${extractErrorMsg(error)} (E: 8f9a0b1c2d3e4f5a6b7c8d9e0f1a2b3c)`);
+        return 1;
+    } finally {
+        if (logalot) {
+            console.log(`${lc} complete. (I: 9f0a1b2c3d4e5f6a7b8c9d0e1f2a3b4c)`);
+        }
+    }
+}
+
+// Auto-run if executed directly as entry script
+const isMainScript = process.argv[1] && (
+    process.argv[1].endsWith('vcs-cli-main.mjs') ||
+    process.argv[1].endsWith('vcs-cli-main.mts') ||
+    process.argv[1].endsWith('vcs')
+);
+
+if (isMainScript) {
+    main().then((code) => {
+        if (code !== 0) {
+            process.exit(code);
+        }
+    }).catch(() => {
+        process.exit(1);
+    });
+}

package/src/engine/branch/branch-graph-helper.mts

@@ -0,0 +1,69 @@
+/**
+ * @module branch-graph-helper
+ * 
+ * Helper for extracting dependency graphs and populating branch spaces.
+ */
+
+import { extractErrorMsg } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+import { IbGib_V1 } from '@ibgib/ts-gib/dist/V1/types.mjs';
+import { getDependencyGraph } from '@ibgib/core-gib/dist/common/other/graph-helper.mjs';
+import { IbGibSpaceAny } from '@ibgib/core-gib/dist/witness/space/space-base-v1.mjs';
+import { putInSpace } from '@ibgib/core-gib/dist/witness/space/space-helper.mjs';
+import { MetaspaceService } from '@ibgib/core-gib/dist/witness/space/metaspace/metaspace-types.mjs';
+
+import { GLOBAL_LOG_A_LOT } from '../../vcs-gib-constants.mjs';
+
+const lcFile = `[branch-graph-helper]`;
+const logalot = GLOBAL_LOG_A_LOT;
+
+export interface PopulateBranchSpaceFromGraphOpts {
+    sourceSpace: IbGibSpaceAny;
+    targetBranchSpace: IbGibSpaceAny;
+    rootItemIbGib: IbGib_V1;
+    metaspace?: MetaspaceService;
+}
+
+/**
+ * Extracts the live dependency graph of rootItemIbGib from sourceSpace and persists all ibgibs into targetBranchSpace.
+ */
+export async function populateBranchSpaceFromGraph({
+    sourceSpace,
+    targetBranchSpace,
+    rootItemIbGib,
+    metaspace,
+}: PopulateBranchSpaceFromGraphOpts): Promise<void> {
+    const lc = `${lcFile}[${populateBranchSpaceFromGraph.name}]`;
+    try {
+        if (logalot) {
+            console.log(`${lc} starting... (I: 1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d)`);
+        }
+
+        if (!sourceSpace || !targetBranchSpace || !rootItemIbGib) {
+            throw new Error(`sourceSpace, targetBranchSpace, and rootItemIbGib are required (E: 2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e)`);
+        }
+
+        const graph = await getDependencyGraph({
+            ibGib: rootItemIbGib,
+            space: sourceSpace,
+            live: true,
+        });
+
+        for (const [addr, ibGib] of Object.entries(graph)) {
+            await putInSpace({ space: targetBranchSpace, ibGib });
+            if (metaspace) {
+                await metaspace.registerNewIbGib({ ibGib, space: targetBranchSpace });
+            }
+        }
+
+        if (logalot) {
+            console.log(`${lc} Populated target branch space with ${Object.keys(graph).length} ibgibs (I: 3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f)`);
+        }
+    } catch (error) {
+        console.error(`${lc} ${extractErrorMsg(error)} (E: 4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a)`);
+        throw error;
+    } finally {
+        if (logalot) {
+            console.log(`${lc} complete. (I: 5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b)`);
+        }
+    }
+}

package/src/engine/branch/branch-helper.mts

@@ -0,0 +1,79 @@
+/**
+ * @module branch-helper
+ * 
+ * B2tFS Branch Helper functions: dedicated branch spaces (`b2s_...`), branch creation,
+ * and branch timeline tracking.
+ */
+
+import { getUUID } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+import { ROOT } from '@ibgib/ts-gib/dist/V1/constants.mjs';
+import { getIbGibAddr } from '@ibgib/ts-gib/dist/helper.mjs';
+import { Factory_V1 } from '@ibgib/ts-gib/dist/V1/factory.mjs';
+import { MetaspaceService } from '@ibgib/core-gib/dist/witness/space/metaspace/metaspace-types.mjs';
+import { IbGibSpaceAny } from '@ibgib/core-gib/dist/witness/space/space-base-v1.mjs';
+import { putInSpace, persistTransformResult } from '@ibgib/core-gib/dist/witness/space/space-helper.mjs';
+
+import { GLOBAL_LOG_A_LOT } from '../../vcs-gib-constants.mjs';
+import { B2tFSBranchIbGib_V1, B2tFSBranchData_V1, B2tFSBranchRel8ns_V1 } from './branch-types.mjs';
+import { B2tFSItemIbGib_V1 } from '../item/item-types.mjs';
+
+const lcFile = `[branch-helper]`;
+const logalot = GLOBAL_LOG_A_LOT;
+
+export const B2TFS_BRANCH_SPACE_PREFIX = 'b2s_';
+
+/**
+ * Generates a dedicated branch space name.
+ * Example: 'main' -> 'b2s_main'
+ */
+export function getB2tFSBranchSpaceName(branchName: string): string {
+    const safeName = branchName.replace(/[^a-zA-Z0-9_\-]/g, '_');
+    return `${B2TFS_BRANCH_SPACE_PREFIX}${safeName}`;
+}
+
+/**
+ * Creates a new B2tFSBranchIbGib pointing to a root folder item.
+ */
+export async function createB2tFSBranchIbGib(opts: {
+    branchName: string;
+    rootItem: B2tFSItemIbGib_V1;
+    space: IbGibSpaceAny;
+    metaspace: MetaspaceService;
+}): Promise<B2tFSBranchIbGib_V1> {
+    const lc = `${lcFile}[${createB2tFSBranchIbGib.name}]`;
+    const { branchName, rootItem, space, metaspace } = opts;
+
+    if (!branchName || !rootItem) {
+        throw new Error(`branchName and rootItem required (E: 9012a472c9104b2d)`);
+    }
+
+    const uuid = await getUUID();
+    const rootAddr = getIbGibAddr({ ibGib: rootItem });
+
+    const data: B2tFSBranchData_V1 = {
+        name: branchName,
+        uuid,
+        classname: 'B2tFSBranchIbGib_V1',
+    };
+
+    const rel8ns: B2tFSBranchRel8ns_V1 = {
+        b2tfs_item: [rootAddr],
+    };
+
+    const res = await Factory_V1.firstGen({
+        parentIbGib: ROOT,
+        ib: `b2tfs_branch ${branchName} v1 ${uuid}`,
+        data,
+        rel8ns,
+    });
+
+    const branchIbGib = res.newIbGib as B2tFSBranchIbGib_V1;
+    await persistTransformResult({ resTransform: res, space });
+    await metaspace.registerNewIbGib({ ibGib: branchIbGib });
+
+    if (logalot) {
+        console.log(`${lc} Created branch IbGib: ${branchIbGib.ib}`);
+    }
+
+    return branchIbGib;
+}

package/src/engine/branch/branch-space-helper.mts

@@ -0,0 +1,104 @@
+/**
+ * @module branch-space-helper
+ * 
+ * Helper for managing dedicated branch spaces (`b2s_...`) in metaspace.
+ */
+
+import { clone, extractErrorMsg, getUUID } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+import { getGib } from '@ibgib/ts-gib/dist/V1/transforms/transform-helper.mjs';
+import { Metaspace_Nodespace } from '@ibgib/node-gib/dist/witness/space/metaspace/metaspace-nodespace/metaspace-nodespace.mjs';
+import { NodeFilesystemSpace_V1 } from '@ibgib/node-gib/dist/witness/space/node-filesystem-space/node-filesystem-space-v1.mjs';
+import { DEFAULT_NODE_FILESYSTEM_SPACE_DATA_V1 } from '@ibgib/node-gib/dist/witness/space/node-filesystem-space/node-filesystem-space-types.mjs';
+import { putInSpace } from '@ibgib/core-gib/dist/witness/space/space-helper.mjs';
+
+import { GLOBAL_LOG_A_LOT } from '../../vcs-gib-constants.mjs';
+import { getB2tFSBranchSpaceName } from './branch-helper.mjs';
+
+const lcFile = `[branch-space-helper]`;
+const logalot = GLOBAL_LOG_A_LOT;
+
+export interface GetOrCreateBranchSpaceOpts {
+    metaspace: Metaspace_Nodespace;
+    vcsPath: string;
+    branchName: string;
+}
+
+export interface GetOrCreateBranchSpaceResult {
+    space: NodeFilesystemSpace_V1;
+    spaceId: string;
+    spaceName: string;
+}
+
+/**
+ * Gets an existing branch space or creates and registers a new dedicated NodeFilesystemSpace_V1 in metaspace.
+ */
+export async function getOrCreateBranchSpace({
+    metaspace,
+    vcsPath,
+    branchName,
+}: GetOrCreateBranchSpaceOpts): Promise<GetOrCreateBranchSpaceResult> {
+    const lc = `${lcFile}[${getOrCreateBranchSpace.name}]`;
+    try {
+        if (logalot) {
+            console.log(`${lc} starting... (I: a1b2c3d4e5f60718293a4b5c6d7e8f9a)`);
+        }
+
+        if (!metaspace || !vcsPath || !branchName) {
+            throw new Error(`metaspace, vcsPath, and branchName are required (E: b2c3d4e5f60718293a4b5c6d7e8f9a0b)`);
+        }
+
+        const spaceName = getB2tFSBranchSpaceName(branchName);
+
+        const localSpaces = await metaspace.getLocalUserSpaces({ lock: false });
+        const existingSpace = localSpaces.find(s => s.data?.name === spaceName || s.ib === spaceName);
+
+        if (existingSpace) {
+            const spaceId = existingSpace.data?.uuid || existingSpace.data?.spaceId || spaceName;
+            if (logalot) {
+                console.log(`${lc} Found existing branch space ${spaceName} (spaceId: ${spaceId}) (I: c3d4e5f60718293a4b5c6d7e8f9a0b1c)`);
+            }
+            return {
+                space: existingSpace as NodeFilesystemSpace_V1,
+                spaceId,
+                spaceName,
+            };
+        }
+
+        const spaceUuid = await getUUID();
+        const spaceData = {
+            ...clone(DEFAULT_NODE_FILESYSTEM_SPACE_DATA_V1),
+            uuid: spaceUuid,
+            isTjp: true,
+            name: spaceName,
+            baseDir: vcsPath,
+            spaceSubPath: spaceName,
+        };
+
+        const space = new NodeFilesystemSpace_V1(spaceData);
+        space.gib = await getGib({ ibGib: space, hasTjp: true });
+        await space.initialized;
+
+        await putInSpace({ space: metaspace.zeroSpace, ibGib: space });
+        await metaspace.registerNewIbGib({ ibGib: space });
+        if (metaspace.fnUpdateBootstrap) {
+            await metaspace.fnUpdateBootstrap(space);
+        }
+
+        if (logalot) {
+            console.log(`${lc} Created new branch space ${spaceName} (spaceId: ${spaceUuid}) (I: d4e5f60718293a4b5c6d7e8f9a0b1c2d)`);
+        }
+
+        return {
+            space,
+            spaceId: spaceUuid,
+            spaceName,
+        };
+    } catch (error) {
+        console.error(`${lc} ${extractErrorMsg(error)} (E: e5f60718293a4b5c6d7e8f9a0b1c2d3e)`);
+        throw error;
+    } finally {
+        if (logalot) {
+            console.log(`${lc} complete. (I: f60718293a4b5c6d7e8f9a0b1c2d3e4f)`);
+        }
+    }
+}

package/src/engine/branch/branch-space.respec.node.mts

@@ -0,0 +1,158 @@
+/**
+ * @module branch-space.respec.node
+ * 
+ * Unit tests for branch space helper, space-qualified address formatting/parsing,
+ * and graph population into branch spaces.
+ */
+
+import path from 'node:path';
+import fs from 'node:fs/promises';
+
+import {
+    respecfully, ifWe, iReckon
+} from '@ibgib/helper-gib/dist/respec-gib/respec-gib.mjs';
+import { ROOT } from '@ibgib/ts-gib/dist/V1/constants.mjs';
+import { Factory_V1 } from '@ibgib/ts-gib/dist/V1/factory.mjs';
+import { getIbGibAddr } from '@ibgib/ts-gib/dist/helper.mjs';
+import { getFromSpace, persistTransformResult } from '@ibgib/core-gib/dist/witness/space/space-helper.mjs';
+
+import { bootstrapVcsMetaspace } from '../../bootstrap/node-bootstrap.mjs';
+import { getB2tFSItemIb } from '../item/item-atom-helper.mjs';
+import { getOrCreateBranchSpace } from './branch-space-helper.mjs';
+import { populateBranchSpaceFromGraph } from './branch-graph-helper.mjs';
+import { getSpaceQualifiedIbGibAddr, parseSpaceQualifiedIbGibAddr } from '../index/index-helper.mjs';
+import { B2tFSItemIbGib_V1 } from '../item/item-types.mjs';
+
+const lc = `[apps/vcs-gib/src/engine/branch/branch-space.respec.node.mts]`;
+
+await respecfully(lc, `Branch Space & Graph Helper Respecs`, async () => {
+
+    await respecfully(lc, `Space-Qualified Address Parsing & Formatting`, async () => {
+        await ifWe(lc, `formats space-qualified address using options object`, async () => {
+            const sq = getSpaceQualifiedIbGibAddr({ spaceId: 'sp_alpha', ibGibAddr: 'item_a^gib123' });
+            iReckon(lc, sq).willEqual('v:1^spaceId:sp_alpha^item_a^gib123');
+        });
+
+        await ifWe(lc, `parses space-qualified address using options object`, async () => {
+            const parsed = parseSpaceQualifiedIbGibAddr({ spaceQualifiedAddr: 'v:1^spaceId:sp_alpha^item_a^gib123' });
+            iReckon(lc, parsed).isGonnaBeTruthy();
+            iReckon(lc, parsed!.version).willEqual(1);
+            iReckon(lc, parsed!.spaceId).willEqual('sp_alpha');
+            iReckon(lc, parsed!.ibGibAddr).willEqual('item_a^gib123');
+            iReckon(lc, parsed!.ib).willEqual('item_a');
+            iReckon(lc, parsed!.gib).willEqual('gib123');
+        });
+
+        await ifWe(lc, `returns null for invalid space-qualified address string`, async () => {
+            const parsed = parseSpaceQualifiedIbGibAddr({ spaceQualifiedAddr: 'invalid_address_string' });
+            iReckon(lc, parsed).isGonnaBeFalsy();
+        });
+    });
+
+    await respecfully(lc, `Branch Space Lifecycle (getOrCreateBranchSpace)`, async () => {
+        await ifWe(lc, `creates a new dedicated branch space and retrieves existing space on second call`, async () => {
+            const testDir = path.join(process.cwd(), '.test_branch_space_repo');
+            try {
+                const { metaspace, vcsPath } = await bootstrapVcsMetaspace({
+                    repoPath: testDir,
+                    vcsFolderName: '.vcsgib_branch_test',
+                    defaultSpaceName: 'test_space',
+                });
+
+                const branchName = 'feature_alpha';
+                const result1 = await getOrCreateBranchSpace({
+                    metaspace,
+                    vcsPath,
+                    branchName,
+                });
+
+                iReckon(lc, result1.spaceName).willEqual('b2s_feature_alpha');
+                iReckon(lc, result1.spaceId).isGonnaBeTruthy();
+                iReckon(lc, result1.space).isGonnaBeTruthy();
+
+                const result2 = await getOrCreateBranchSpace({
+                    metaspace,
+                    vcsPath,
+                    branchName,
+                });
+
+                iReckon(lc, result2.spaceName).willEqual('b2s_feature_alpha');
+                iReckon(lc, result2.spaceId).willEqual(result1.spaceId);
+            } finally {
+                await fs.rm(testDir, { recursive: true, force: true });
+            }
+        });
+    });
+
+    await respecfully(lc, `Graph Population (populateBranchSpaceFromGraph)`, async () => {
+        await ifWe(lc, `populates target branch space with full dependency graph of root item`, async () => {
+            const testDir = path.join(process.cwd(), '.test_populate_graph_repo');
+            try {
+                const { metaspace, localSpace, vcsPath } = await bootstrapVcsMetaspace({
+                    repoPath: testDir,
+                    vcsFolderName: '.vcsgib_populate_test',
+                    defaultSpaceName: 'test_space',
+                });
+
+                // Create child file item
+                const childRes = await Factory_V1.firstGen({
+                    parentIbGib: ROOT,
+                    ib: getB2tFSItemIb('file', 'file.txt', 'file_hash'),
+                    data: {
+                        name: 'file.txt',
+                        nameHash: 'file_hash',
+                        fsType: 'file',
+                        diffTransactionId: 'tx_child',
+                    },
+                });
+                const childItem = childRes.newIbGib as B2tFSItemIbGib_V1;
+                const childAddr = getIbGibAddr({ ibGib: childItem });
+                await persistTransformResult({ resTransform: childRes, space: localSpace });
+                await metaspace.registerNewIbGib({ ibGib: childItem });
+
+                // Create root folder item referencing child
+                const rootRes = await Factory_V1.firstGen({
+                    parentIbGib: ROOT,
+                    ib: getB2tFSItemIb('folder', 'root', 'root_hash'),
+                    data: {
+                        name: 'root',
+                        nameHash: 'root_hash',
+                        fsType: 'folder',
+                        diffTransactionId: 'tx_root',
+                    },
+                    rel8ns: {
+                        b2tfs_item: [childAddr],
+                    },
+                });
+                const rootItem = rootRes.newIbGib as B2tFSItemIbGib_V1;
+                const rootAddr = getIbGibAddr({ ibGib: rootItem });
+                await persistTransformResult({ resTransform: rootRes, space: localSpace });
+                await metaspace.registerNewIbGib({ ibGib: rootItem });
+
+                // Create target branch space
+                const { space: targetBranchSpace } = await getOrCreateBranchSpace({
+                    metaspace,
+                    vcsPath,
+                    branchName: 'main',
+                });
+
+                // Populate target branch space from source localSpace graph
+                await populateBranchSpaceFromGraph({
+                    sourceSpace: localSpace,
+                    targetBranchSpace,
+                    rootItemIbGib: rootItem,
+                    metaspace,
+                });
+
+                // Verify items exist in targetBranchSpace
+                const rootGet = await getFromSpace({ space: targetBranchSpace, addr: rootAddr });
+                iReckon(lc, rootGet).isGonnaBeTruthy();
+
+                const childGet = await getFromSpace({ space: targetBranchSpace, addr: childAddr });
+                iReckon(lc, childGet).isGonnaBeTruthy();
+            } finally {
+                await fs.rm(testDir, { recursive: true, force: true });
+            }
+        });
+    });
+});

package/src/engine/branch/branch-types.mts

@@ -0,0 +1,29 @@
+/**
+ * @module branch-types
+ * 
+ * B2tFS Branch type definitions.
+ */
+
+import { IbGibAddr } from '@ibgib/ts-gib/dist/types.mjs';
+import { IbGibData_V1, IbGibRel8ns_V1, IbGib_V1 } from '@ibgib/ts-gib/dist/V1/types.mjs';
+
+export interface B2tFSBranchData_V1 extends IbGibData_V1 {
+    /**
+     * Branch name (e.g. 'main', 'feature/login')
+     */
+    name: string;
+    /**
+     * Relative path from repository root to working directory
+     */
+    relativePathFromMetaspaceToFSPath?: string;
+}
+
+export interface B2tFSBranchRel8ns_V1 extends IbGibRel8ns_V1 {
+    /**
+     * Link pointing to the root folder B2tFSItemIbGib_V1
+     */
+    b2tfs_item?: IbGibAddr[];
+}
+
+export interface B2tFSBranchIbGib_V1 extends IbGib_V1<B2tFSBranchData_V1, B2tFSBranchRel8ns_V1> {
+}