@ibgib/node-gib 0.0.2

package/src/witness/space/node-filesystem-space/node-indexed-filesystem-space/node-indexed-filesystem-space-types.mts

@@ -0,0 +1,68 @@
+/**
+ * @module node-indexed-filesystem-space-types
+ */
+
+import { IbGib_V1 } from '@ibgib/ts-gib/dist/V1/types.mjs';
+import {
+    NodeFilesystemSpaceData_V1,
+    NodeFilesystemSpaceRel8ns_V1,
+} from '../node-filesystem-space-types.mjs';
+import { DEFAULT_LOCAL_SPACE_POLLING_INTERVAL_MS, IBGIB_SPACE_NAME_DEFAULT, ZERO_SPACE_ID } from '@ibgib/core-gib/dist/witness/space/space-constants.mjs';
+import {
+    DEFAULT_LONG_PATH_LENGTH, IBGIB_BASE_DIR, IBGIB_BASE_SUBPATH,
+    IBGIB_BIN_SUBPATH, IBGIB_DNA_SUBPATH, IBGIB_ENCODING, IBGIB_IBGIBS_SUBPATH,
+    IBGIB_LONG_SUBPATH, IBGIB_META_SUBPATH, IBGIB_SPACE_SUBPATH_DEFAULT
+} from '@ibgib/core-gib/dist/witness/space/filesystem-space/filesystem-constants.mjs';
+import { DEFAULT_INDEXED_FILESYSTEM_SPACE_DESCRIPTION } from './node-indexed-filesystem-space-constants.mjs';
+
+/**
+ * Data for indexed filesystem space.
+ */
+export interface NodeIndexedFilesystemSpaceData_V1 extends NodeFilesystemSpaceData_V1 {
+}
+
+/**
+ * Rel8ns for indexed filesystem space.
+ */
+export interface NodeIndexedFilesystemSpaceRel8ns_V1 extends NodeFilesystemSpaceRel8ns_V1 {
+}
+
+/**
+ * IbGib representing the indexed filesystem space.
+ * Does not descend from a NodeFilesystemSpace ibgib type, just the base IbGib_V1.
+ */
+export interface NodeIndexedFilesystemSpaceIbGib_V1
+    extends IbGib_V1<NodeIndexedFilesystemSpaceData_V1, NodeIndexedFilesystemSpaceRel8ns_V1> {
+}
+
+/**
+ * Used in bootstrapping.
+ *
+ * If you change this, please bump the version
+ *
+ * (but of course won't be the end of the world when this doesn't happen).
+ */
+export const DEFAULT_NODE_INDEXED_FILESYSTEM_SPACE_DATA_V1: NodeIndexedFilesystemSpaceData_V1 = {
+    version: '2',
+    uuid: ZERO_SPACE_ID,
+    name: IBGIB_SPACE_NAME_DEFAULT,
+    classname: 'NodeIndexedFilesystemSpace_V1',
+    baseDir: IBGIB_BASE_DIR,
+    encoding: IBGIB_ENCODING,
+    baseSubPath: IBGIB_BASE_SUBPATH,
+    spaceSubPath: IBGIB_SPACE_SUBPATH_DEFAULT,
+    ibgibsSubPath: IBGIB_IBGIBS_SUBPATH,
+    metaSubPath: IBGIB_META_SUBPATH,
+    binSubPath: IBGIB_BIN_SUBPATH,
+    dnaSubPath: IBGIB_DNA_SUBPATH,
+    longSubPath: IBGIB_LONG_SUBPATH,
+    mitigateLongPaths: false,
+    longPathLength: DEFAULT_LONG_PATH_LENGTH,
+    persistOptsAndResultIbGibs: false,
+    validateIbGibAddrsMatchIbGibs: false,
+    longPollingIntervalMs: DEFAULT_LOCAL_SPACE_POLLING_INTERVAL_MS,
+    allowPrimitiveArgs: false,
+    catchAllErrors: true,
+    description: DEFAULT_INDEXED_FILESYSTEM_SPACE_DESCRIPTION,
+    trace: false,
+}

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

@@ -0,0 +1,403 @@
+import { existsSync, mkdirSync } from 'node:fs';
+import { writeFile, rm, readFile, readdir } from 'node:fs/promises';
+import { default as pathUtils, join } from 'path';
+
+import { clone, extractErrorMsg } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+import { getIbAndGib, getIbGibAddr } from '@ibgib/ts-gib/dist/helper.mjs';
+import { getGibInfo } from '@ibgib/ts-gib/dist/V1/transforms/transform-helper.mjs';
+import { IbGib_V1, IbGibRel8ns_V1 } from '@ibgib/ts-gib/dist/V1/types.mjs';
+import { toDto, isBinary, } from '@ibgib/core-gib/dist/common/other/ibgib-helper.mjs';
+import {
+    PutIbGibFileOpts, PutIbGibFileResult, GetIbGibFileOpts, GetIbGibFileResult,
+    DeleteIbGibFileOpts, DeleteIbGibFilesResult,
+} from '@ibgib/core-gib/dist/witness/space/filesystem-space/filesystem-types.mjs';
+import { isMetaStone, parseMetaStoneIb } from '@ibgib/core-gib/dist/common/meta-stone/meta-stone-helper.mjs';
+
+import { GLOBAL_LOG_A_LOT } from '../../../../constants.mjs';
+import { NodeFilesystemSpace_V1 } from '../node-filesystem-space-v1.mjs';
+import { DEFAULT_NODE_FILESYSTEM_SPACE_DATA_V1, NodeFilesystemSpaceData_V1, NodeFilesystemSpaceRel8ns_V1 } from '../node-filesystem-space-types.mjs';
+import { DEFAULT_NODE_INDEXED_FILESYSTEM_SPACE_DATA_V1 } from './node-indexed-filesystem-space-types.mjs';
+
+const logalot = GLOBAL_LOG_A_LOT;
+
+const INDEX_DIR_NAME = '.idx';
+const MAP_EXTENSION = '.map';
+
+/**
+ * Mapping from Full IbGib Address -> Short Filename
+ */
+interface IndexMap {
+    [addr: string]: string;
+}
+
+/**
+ * Robust filesystem space that uses a distributed index folder strategy (.idx)
+ * to avoid Windows MAX_PATH issues while maintaining TJP grouping.
+ */
+export class NodeIndexedFilesystemSpace_V1<
+    TData extends NodeFilesystemSpaceData_V1 = NodeFilesystemSpaceData_V1,
+    TRel8ns extends NodeFilesystemSpaceRel8ns_V1 = NodeFilesystemSpaceRel8ns_V1
+> extends NodeFilesystemSpace_V1<TData, TRel8ns> {
+
+    protected override lc: string = `[${NodeIndexedFilesystemSpace_V1.name}]`;
+
+    /**
+     * in case the caller tries to override the classname. This should be overridden in any descendant classes
+     */
+    get classname(): string { return NodeIndexedFilesystemSpace_V1.name; }
+
+    /**
+     * Factory static method to create the space with the given
+     * `dto` param's ibGib properties.
+     *
+     * We do this because when we persist this space (and its settings
+     * located in `data`), we do not save the actual class instantiation
+     * but just the ibgib properties. Use this factory method to
+     * create a new space instance and rehydrate from that saved dto.
+     *
+     * ## notes
+     *
+     * * DTO stands for data transfer object.
+     *
+     * @param dto space ibGib dto that we're going to load from
+     * @returns newly created space built upon `dto`
+     */
+    static async createFromDto<
+        TData extends NodeFilesystemSpaceData_V1 = NodeFilesystemSpaceData_V1,
+        TRel8ns extends IbGibRel8ns_V1 = IbGibRel8ns_V1
+    >(dto: IbGib_V1<TData, TRel8ns>): Promise<NodeFilesystemSpace_V1<TData, TRel8ns>> {
+        const lc = `[${NodeIndexedFilesystemSpace_V1.name}][${this.createFromDto.name}]`;
+        if (logalot) { console.log(`${lc}`); }
+        const space = new NodeIndexedFilesystemSpace_V1<TData, TRel8ns>(dto.data); // shouldn't have to do this
+        await space.initialized;
+        await space.loadIbGibDto(dto);
+        return space;
+    }
+
+    constructor(
+        // /**
+        //  * Default predicate value when putting an unknown ibGib.
+        //  *
+        //  * ## notes
+        //  *
+        //  * So when a repo witnesses another ibGib, it either defaults to
+        //  * storing that ibGib or not storing that ibGib. This is what that
+        //  * is referring to. If it's optimistic, then it stores any ibGib by
+        //  * default and it passes its put predicate.
+        //  */
+        // public optimisticPut: boolean = true,
+        initialData?: TData,
+        initialRel8ns?: TRel8ns,
+    ) {
+        super(initialData ?? clone(DEFAULT_NODE_INDEXED_FILESYSTEM_SPACE_DATA_V1), initialRel8ns);
+        const lc = `${this.lc}[ctor]`;
+
+        // try {
+        //     if (logalot) { console.log(`${lc} starting...`); }
+        //     this.initialize();
+        // } catch (error) {
+        //     console.error(`${lc} ${extractErrorMsg(error)}`);
+        //     throw error;
+        // } finally {
+        //     if (logalot) { console.log(`${lc} complete.`); }
+        // }
+    }
+
+    /**
+     * Overrides the path building to be "Index Aware".
+     * In this implementation, the "path" returned is the bucket directory.
+     * The actual filename is resolved via the index.
+     */
+    protected override async buildPath(opts: any): Promise<string> {
+        const { addr, isDna, isBin, addrIsForAMetaStone } = opts;
+        const { ib, gib } = getIbAndGib({ ibGibAddr: addr });
+
+        // Primitive ibgibs do not need bucket indexing, delegate to original un-indexed logic
+        if (gib === 'gib') {
+            return super.buildPath(opts);
+        }
+
+        let subPath = '';
+        if (isDna) { subPath = this.data!.dnaSubPath!; }
+        else if (isBin) { subPath = this.data!.binSubPath!; }
+        else if (addrIsForAMetaStone || isMetaStone({ addr })) { subPath = this.data!.metaSubPath!; }
+        else { subPath = this.data!.ibgibsSubPath!; }
+
+        return this.buildPath_withSubPath({ addr, subPath });
+    }
+
+    protected async buildPath_withSubPath(opts: { addr: string, subPath: string }): Promise<string> {
+        const { addr, subPath } = opts;
+        const { ib, gib } = getIbAndGib({ ibGibAddr: addr });
+
+        // Deterministic Bucket based on first 6 chars of gib (or ib if gib is primitive)
+        let hashBase = (gib && gib !== 'gib') ? gib : ib;
+
+        // Special handling for metastones: group by target TJP
+        if (isMetaStone({ addr })) {
+            hashBase = parseMetaStoneIb({ ib }).tjpGib;
+        } else {
+            const gibInfo = getGibInfo({ ibGibAddr: addr });
+            if (gibInfo.tjpGib) {
+                hashBase = gibInfo.tjpGib;
+            }
+        }
+
+        const bucket1 = hashBase.substring(0, 3).toUpperCase();
+        const bucket2 = hashBase.substring(3, 6).toUpperCase();
+
+        // Root/Space/SubPath/B1/B2
+        return pathUtils.join(
+            this.data!.baseSubPath!,
+            this.data!.spaceSubPath!,
+            subPath,
+            bucket1,
+            bucket2
+        );
+    }
+
+    /**
+     * Resolves the actual filename for an address using the index.
+     */
+    protected async resolveFilename(bucketPath: string, addr: string): Promise<string | undefined> {
+        const mapFilePath = this.getMapFilePath(bucketPath, addr);
+        if (!existsSync(mapFilePath)) { return undefined; }
+
+        try {
+            const content = await readFile(mapFilePath, 'utf8');
+            const map: IndexMap = JSON.parse(content);
+            return map[addr];
+        } catch (error) {
+            console.error(`${this.lc} Error reading map file ${mapFilePath}: ${extractErrorMsg(error)}`);
+            return undefined;
+        }
+    }
+
+    /**
+     * Updates the index with a new mapping.
+     */
+    protected async updateIndex(bucketPath: string, addr: string, filename: string): Promise<void> {
+        const indexDir = join(bucketPath, INDEX_DIR_NAME);
+        if (!existsSync(indexDir)) {
+            mkdirSync(indexDir, { recursive: true });
+        }
+
+        const mapFilePath = this.getMapFilePath(bucketPath, addr);
+        let map: IndexMap = {};
+
+        if (existsSync(mapFilePath)) {
+            try {
+                const content = await readFile(mapFilePath, 'utf8');
+                map = JSON.parse(content);
+            } catch (error) {
+                console.warn(`${this.lc} Map file ${mapFilePath} corrupted, overwriting. (W: 4129bd5e921d4d8e87491d9e2a84423)`);
+            }
+        }
+
+        map[addr] = filename;
+        await writeFile(mapFilePath, JSON.stringify(map, null, 2));
+    }
+
+    protected getMapFilePath(bucketPath: string, addr: string): string {
+        const { gib } = getIbAndGib({ ibGibAddr: addr });
+        // Use next 4 chars of hash for map filename distribution
+        const mapName = (gib.length > 10 ? gib.substring(6, 10) : 'default').toUpperCase();
+        return join(bucketPath, INDEX_DIR_NAME, `${mapName}${MAP_EXTENSION}`);
+    }
+
+    protected override async putFile(opts: PutIbGibFileOpts): Promise<PutIbGibFileResult> {
+        const lc = `${this.lc}[putFile]`;
+        const { ibGib, isDna } = opts;
+        if (!ibGib) { throw new Error('ibGib required'); }
+
+        const addr = getIbGibAddr({ ibGib });
+        const { gib } = getIbAndGib({ ibGibAddr: addr });
+
+        // Primitive ibgibs bypass indexing completely
+        if (gib === 'gib') {
+            return super.putFile(opts);
+        }
+
+        const bucketPath = join(this.data!.baseDir, await this.buildPath({
+            addr, isDna, isBin: isBinary({ addr }), addrIsForAMetaStone: isMetaStone({ addr })
+        }));
+
+        if (!existsSync(bucketPath)) {
+            mkdirSync(bucketPath, { recursive: true });
+        }
+
+        // 1. Resolve or Generate Filename
+        let filename = await this.resolveFilename(bucketPath, addr);
+        if (!filename) {
+            // Generate a random but safe filename
+            const randomId = Math.random().toString(36).substring(2, 8);
+            filename = `${randomId}.json`;
+        }
+
+        const fullPath = join(bucketPath, filename);
+
+        // 2. Write Data
+        try {
+            const data = JSON.stringify(toDto({ ibGib }), null, 2);
+            await writeFile(fullPath, data, this.data!.encoding as BufferEncoding);
+
+            // 3. Update Index
+            await this.updateIndex(bucketPath, addr, filename);
+            return { success: true };
+        } catch (error) {
+            return { success: false, errorMsg: extractErrorMsg(error) };
+        }
+    }
+
+    protected override async getFile(opts: GetIbGibFileOpts): Promise<GetIbGibFileResult> {
+        const lc = `${this.lc}[getFile]`;
+        const addr = opts.addr;
+        if (!addr) { throw new Error('addr required'); }
+
+        const { ib, gib } = getIbAndGib({ ibGibAddr: addr });
+
+        // Primitive ibgibs bypass indexing completely
+        if (gib === 'gib') {
+            return super.getFile(opts);
+        }
+
+        const isBin = isBinary({ addr });
+        const addrIsMetaStone = isMetaStone({ addr });
+
+        // Build list of subpaths to try
+        const subPathsToTry: string[] = [];
+
+        if (opts.isDna) {
+            subPathsToTry.push(this.data!.dnaSubPath!);
+        } else if (isBin) {
+            subPathsToTry.push(this.data!.binSubPath!);
+        } else if (addrIsMetaStone) {
+            subPathsToTry.push(this.data!.metaSubPath!);
+        } else {
+            // Might be DNA if not explicitly told, check dna first as optimization if ib is a transform
+            const { ib } = getIbAndGib({ ibGibAddr: addr });
+            const knownTransformIbs = ['fork', 'mut8', 'rel8', 'plan'];
+            const addrMightBeDna = knownTransformIbs.some(x => x === ib || x.startsWith(ib + ' '));
+
+            if (addrMightBeDna) {
+                subPathsToTry.push(this.data!.dnaSubPath!);
+            }
+            subPathsToTry.push(this.data!.ibgibsSubPath!);
+            if (!addrMightBeDna) {
+                subPathsToTry.push(this.data!.dnaSubPath!);
+            }
+        }
+
+        for (const subPath of subPathsToTry) {
+            const relBucketPath = await this.buildPath_withSubPath({ addr, subPath });
+            const bucketPath = join(this.data!.baseDir, relBucketPath);
+            const filename = await this.resolveFilename(bucketPath, addr);
+            if (filename) {
+                const fullPath = join(bucketPath, filename);
+                if (existsSync(fullPath)) {
+                    try {
+                        const content = await readFile(fullPath, 'utf8');
+                        const ibGib = JSON.parse(content) as IbGib_V1;
+                        return { success: true, ibGib };
+                    } catch (error) {
+                        if (logalot) { console.error(`${lc} error reading ${fullPath}: ${extractErrorMsg(error)}`); }
+                    }
+                }
+            }
+        }
+
+        return { success: true };
+    }
+
+    protected override async deleteFile(opts: DeleteIbGibFileOpts): Promise<DeleteIbGibFilesResult> {
+        const addr = opts.addr;
+        if (!addr) { throw new Error('addr required'); }
+
+        const { gib } = getIbAndGib({ ibGibAddr: addr });
+
+        // Primitive ibgibs bypass indexing completely
+        if (gib === 'gib') {
+            return super.deleteFile(opts);
+        }
+
+        const bucketPath = join(this.data!.baseDir, await this.buildPath({
+            addr, isDna: opts.isDna, isBin: isBinary({ addr }), addrIsForAMetaStone: isMetaStone({ addr })
+        }));
+
+        const filename = await this.resolveFilename(bucketPath, addr);
+        if (!filename) { return { success: true }; }
+
+        const fullPath = join(bucketPath, filename);
+        try {
+            if (existsSync(fullPath)) {
+                await rm(fullPath);
+            }
+
+            // Remove from index
+            const mapFilePath = this.getMapFilePath(bucketPath, addr);
+            if (existsSync(mapFilePath)) {
+                const content = await readFile(mapFilePath, 'utf8');
+                const map: IndexMap = JSON.parse(content);
+                delete map[addr];
+                if (Object.keys(map).length === 0) {
+                    await rm(mapFilePath);
+                } else {
+                    await writeFile(mapFilePath, JSON.stringify(map, null, 2));
+                }
+            }
+            return { success: true };
+        } catch (error) {
+            return { success: false, errorMsg: extractErrorMsg(error) };
+        }
+    }
+
+    /**
+     * Overrides getMetaStoneAddrs to look in the bucketed directory.
+     */
+    protected override async getMetaStoneAddrs(opts: {
+        ibGibAddr: string,
+        tjpGib: string,
+        fnFilterIb?: (ib: string) => boolean,
+    }): Promise<string[]> {
+        const { ibGibAddr, tjpGib, fnFilterIb } = opts;
+        const lc = `${this.lc}[getMetaStoneAddrs]`;
+
+        // Get the bucket path for metastones for this TJP
+        const relBucketPath = await this.buildPath({
+            addr: ibGibAddr,
+            addrIsForAMetaStone: true
+        });
+        const bucketPath = join(this.data!.baseDir, relBucketPath);
+
+        if (!existsSync(bucketPath)) { return []; }
+
+        const indexDir = join(bucketPath, INDEX_DIR_NAME);
+        if (!existsSync(indexDir)) { return []; }
+
+        const metaStoneAddrs: string[] = [];
+
+        try {
+            const mapFiles = (await readdir(indexDir)).filter(f => f.endsWith(MAP_EXTENSION));
+
+            for (const mapFile of mapFiles) {
+                const content = await readFile(join(indexDir, mapFile), 'utf8');
+                const map: IndexMap = JSON.parse(content);
+                for (const addr of Object.keys(map)) {
+                    if (isMetaStone({ addr })) {
+                        const { ib } = getIbAndGib({ ibGibAddr: addr });
+                        const metaStoneInfo = parseMetaStoneIb({ ib });
+                        if (metaStoneInfo.tjpGib === tjpGib) {
+                            if (!fnFilterIb || fnFilterIb(ib)) {
+                                metaStoneAddrs.push(addr);
+                            }
+                        }
+                    }
+                }
+            }
+        } catch (error) {
+            if (logalot) { console.error(`${lc} error reading metastone index: ${extractErrorMsg(error)}`); }
+        }
+
+        return metaStoneAddrs;
+    }
+}

package/src/witness/space/node-filesystem-space/node-indexed-filesystem-space/respec/testSpace_createAndInit.node-indexed-filesystem-space-v1.respec.mts

@@ -0,0 +1,68 @@
+import { rm } from 'node:fs/promises';
+
+import {
+    respecfully,
+} from '@ibgib/helper-gib/dist/respec-gib/respec-gib.mjs';
+const maam = `[${import.meta.url}]`, sir = maam;
+
+import {
+    testSpace_createAndInit,
+} from '@ibgib/core-gib/dist/witness/space/space-respec-helper.mjs';
+import {
+    getCurrentFilename, specGetBaseDir, specGetBaseSubPath, specGetSpaceDescription,
+    specGetSpaceId, specGetSpaceName
+} from '@ibgib/core-gib/dist/spec-helper.node.respec.mjs';
+import { NodeIndexedFilesystemSpace_V1 } from '../node-indexed-filesystem-space-v1.mjs';
+import { IBGIB_ENCODING } from '@ibgib/core-gib/dist/witness/space/filesystem-space/filesystem-constants.mjs';
+import { NodeFilesystemSpaceData_V1 } from '../../node-filesystem-space-types.mjs';
+
+const logalot = false;
+const TEST_BASE_DIR_ROOT = (await getCurrentFilename(import.meta.url)).replace('testSpace_', '').substring(0, 18) + '_troot';
+const lc = `[${TEST_BASE_DIR_ROOT}]`;
+
+const fnGetInitialRel8ns = () => {
+    return Promise.resolve(undefined);
+};
+
+const fnGetSpace = async (initialData: any, initialRel8ns: any) => {
+    const space = new NodeIndexedFilesystemSpace_V1(initialData, initialRel8ns);
+    return space;
+};
+
+await respecfully(sir, `[${NodeIndexedFilesystemSpace_V1.name} specs]`, async () => {
+
+    console.log('---'); // output buffer
+    console.log('---'); // output buffer
+    await testSpace_createAndInit({
+        respecfulTitle: sir,
+        fnGetInitialSpaceData: async () => {
+            const uuid = await specGetSpaceId();
+            return {
+                version: '1',
+                classname: NodeIndexedFilesystemSpace_V1.name,
+                uuid,
+                name: specGetSpaceName(uuid),
+                description: specGetSpaceDescription(uuid),
+                baseDir: specGetBaseDir(TEST_BASE_DIR_ROOT, uuid, logalot, lc),
+                baseSubPath: specGetBaseSubPath(TEST_BASE_DIR_ROOT, uuid, logalot, lc),
+                binSubPath: 'bin',
+                dnaSubPath: 'dna',
+                encoding: IBGIB_ENCODING,
+                ibgibsSubPath: 'ibgibs',
+                metaSubPath: 'meta',
+                spaceSubPath: 'space',
+                allowPrimitiveArgs: false,
+                catchAllErrors: false,
+                longPollingIntervalMs: 500,
+                persistOptsAndResultIbGibs: false,
+                trace: false,
+                validateIbGibAddrsMatchIbGibs: false,
+            } satisfies NodeFilesystemSpaceData_V1;
+        },
+        fnGetInitialSpaceRel8ns: fnGetInitialRel8ns,
+        fnGetSpace,
+    })
+    console.log('---'); // output buffer
+    console.log('---'); // output buffer
+
+});

package/src/witness/space/node-filesystem-space/node-indexed-filesystem-space/respec/testSpace_persistTransformResult.node-indexed-filesystem-space-v1.respec.mts

@@ -0,0 +1,70 @@
+import { rm } from 'node:fs/promises';
+
+import {
+    respecfully,
+    respecfullyDear,
+} from '@ibgib/helper-gib/dist/respec-gib/respec-gib.mjs';
+const maam = `[${import.meta.url}]`, sir = maam;
+
+import {
+    testSpace_persistTransformResult,
+} from '@ibgib/core-gib/dist/witness/space/space-respec-helper.mjs';
+import {
+    getCurrentFilename, specGetBaseDir, specGetBaseSubPath, specGetSpaceDescription,
+    specGetSpaceId, specGetSpaceName
+} from '@ibgib/core-gib/dist/spec-helper.node.respec.mjs';
+import { NodeIndexedFilesystemSpace_V1 } from '../node-indexed-filesystem-space-v1.mjs';
+import { IBGIB_ENCODING } from '@ibgib/core-gib/dist/witness/space/filesystem-space/filesystem-constants.mjs';
+import { NodeFilesystemSpaceData_V1 } from '../../node-filesystem-space-types.mjs';
+
+const logalot = false;
+const TEST_BASE_DIR_ROOT = (await getCurrentFilename(import.meta.url)).replace('testSpace_', '').substring(0, 18) + '_troot';
+const lc = `[${TEST_BASE_DIR_ROOT}]`;
+
+const fnGetInitialRel8ns = () => {
+    return Promise.resolve(undefined);
+};
+
+const fnGetSpace = async (initialData: any, initialRel8ns: any) => {
+    const space = new NodeIndexedFilesystemSpace_V1(initialData, initialRel8ns);
+    return space;
+};
+
+await respecfully(sir, `[${NodeIndexedFilesystemSpace_V1.name} specs]`, async () => {
+
+    console.log('---'); // output buffer
+    console.log('---'); // output buffer
+    await testSpace_persistTransformResult({
+        respecfulTitle: sir,
+        // shortcircuitRespec: true,
+        fnGetInitialSpaceData: async () => {
+            const uuid = await specGetSpaceId();
+            return {
+                version: '1',
+                classname: NodeIndexedFilesystemSpace_V1.name,
+                uuid,
+                name: specGetSpaceName(uuid),
+                description: specGetSpaceDescription(uuid),
+                baseDir: specGetBaseDir(TEST_BASE_DIR_ROOT, uuid, logalot, lc),
+                baseSubPath: specGetBaseSubPath(TEST_BASE_DIR_ROOT, uuid, logalot, lc),
+                binSubPath: 'bin',
+                dnaSubPath: 'dna',
+                encoding: IBGIB_ENCODING,
+                ibgibsSubPath: 'ibgibs',
+                metaSubPath: 'meta',
+                spaceSubPath: 'space',
+                allowPrimitiveArgs: false,
+                catchAllErrors: false,
+                longPollingIntervalMs: 500,
+                persistOptsAndResultIbGibs: false,
+                trace: false,
+                validateIbGibAddrsMatchIbGibs: false,
+            } satisfies NodeFilesystemSpaceData_V1;
+        },
+        fnGetInitialSpaceRel8ns: fnGetInitialRel8ns,
+        fnGetSpace,
+    })
+    console.log('---'); // output buffer
+    console.log('---'); // output buffer
+
+});

package/src/witness/space/node-filesystem-space/node-indexed-filesystem-space/respec/testSpace_putGetDelete.node-indexed-filesystem-space-v1.respec.mts

@@ -0,0 +1,72 @@
+import { rm } from 'node:fs/promises';
+
+import {
+    respecfully,
+} from '@ibgib/helper-gib/dist/respec-gib/respec-gib.mjs';
+const maam = `[${import.meta.url}]`, sir = maam;
+
+import { testSpace_putGetDelete, } from '@ibgib/core-gib/dist/witness/space/space-respec-helper.mjs';
+import {
+    getCurrentFilename, specGetBaseDir, specGetBaseSubPath,
+    specGetSpaceDescription, specGetSpaceId, specGetSpaceName
+} from '@ibgib/core-gib/dist/spec-helper.node.respec.mjs';
+import { IBGIB_ENCODING } from '@ibgib/core-gib/dist/witness/space/filesystem-space/filesystem-constants.mjs';
+
+import { NodeIndexedFilesystemSpace_V1 } from '../node-indexed-filesystem-space-v1.mjs';
+
+const logalot = false;
+const TEST_BASE_DIR_ROOT = (await getCurrentFilename(import.meta.url)).replace('testSpace_', '').substring(0, 18) + '_troot';
+const lc = `[${TEST_BASE_DIR_ROOT}]`;
+
+const fnGetInitialRel8ns = () => {
+    return Promise.resolve(undefined);
+};
+
+const fnGetSpace = async (initialData: any, initialRel8ns: any) => {
+    const space = new NodeIndexedFilesystemSpace_V1(initialData, initialRel8ns);
+    return space;
+};
+
+await respecfully(sir, `[${lc} respecs]`, async () => {
+    // Clean up after tests
+    // lastOfAll(sir, async () => {
+    //     await rm(TEST_BASE_DIR_ROOT, {
+    //         recursive: true,
+    //         force: true,
+    //     });
+    // });
+
+    console.log('---'); // output buffer
+    console.log('---'); // output buffer
+    await testSpace_putGetDelete({
+        respecfulTitle: sir,
+        fnGetInitialSpaceData: async () => {
+            const uuid = await specGetSpaceId();
+            return {
+                version: '1',
+                classname: 'NodeIndexedFilesystemSpace_V1',
+                uuid,
+                name: specGetSpaceName(uuid),
+                description: specGetSpaceDescription(uuid),
+                baseDir: specGetBaseDir(TEST_BASE_DIR_ROOT, uuid, logalot, lc),
+                baseSubPath: specGetBaseSubPath(TEST_BASE_DIR_ROOT, uuid, logalot, lc),
+                binSubPath: 'bin',
+                dnaSubPath: 'dna',
+                encoding: IBGIB_ENCODING,
+                ibgibsSubPath: 'ibgibs',
+                metaSubPath: 'meta',
+                spaceSubPath: 'space',
+                allowPrimitiveArgs: false,
+                catchAllErrors: false,
+                longPollingIntervalMs: 500,
+                persistOptsAndResultIbGibs: false,
+                trace: false,
+                validateIbGibAddrsMatchIbGibs: false,
+            };
+        },
+        fnGetInitialSpaceRel8ns: fnGetInitialRel8ns,
+        fnGetSpace,
+    });
+    console.log('---'); // output buffer
+    console.log('---'); // output buffer
+});