@nimbus-sh/core 0.1.0

package/dist/substrate/lifo/kernel/storage/BlobStore.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Compute a 64-bit FNV-1a hash of the given bytes and return it as a
+ * 16-character lowercase hex string.
+ *
+ * We split the 64-bit state into two 32-bit halves (high, low) and apply
+ * the FNV-1a algorithm byte-by-byte: xor then multiply by the prime.
+ */
+export declare function hashBytes(data: Uint8Array): string;
+export interface BlobStore {
+    get(hash: string): Promise<Uint8Array | null>;
+    put(data: Uint8Array): Promise<string>;
+    delete(hash: string): Promise<void>;
+    has(hash: string): Promise<boolean>;
+}
+export declare class MemoryBlobStore implements BlobStore {
+    private blobs;
+    get(hash: string): Promise<Uint8Array | null>;
+    put(data: Uint8Array): Promise<string>;
+    delete(hash: string): Promise<void>;
+    has(hash: string): Promise<boolean>;
+}
+//# sourceMappingURL=BlobStore.d.ts.map

package/dist/substrate/lifo/kernel/storage/BlobStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlobStore.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/kernel/storage/BlobStore.ts"],"names":[],"mappings":"AAeA;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAgDlD;AAMD,MAAM,WAAW,SAAS;IACxB,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC;IAC9C,GAAG,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACvC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACpC,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACrC;AAMD,qBAAa,eAAgB,YAAW,SAAS;IAC/C,OAAO,CAAC,KAAK,CAAiC;IAExC,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC;IAO7C,GAAG,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC;IAStC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAInC,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;CAG1C"}

package/dist/substrate/lifo/kernel/storage/BlobStore.js

@@ -0,0 +1,84 @@
+// Content-addressable blob storage using FNV-1a hashing.
+// No external dependencies.
+// ---------------------------------------------------------------------------
+// FNV-1a 64-bit hash
+// ---------------------------------------------------------------------------
+// FNV-1a 64-bit offset basis: 0xcbf29ce484222325
+const FNV_OFFSET_HIGH = 0xcbf29ce4;
+const FNV_OFFSET_LOW = 0x84222325;
+// FNV-1a 64-bit prime: 0x00000100000001b3
+const FNV_PRIME_LOW = 0x000001b3;
+const FNV_PRIME_HIGH_BYTE = 0x01; // the 0x100 component that lands in the high word
+/**
+ * Compute a 64-bit FNV-1a hash of the given bytes and return it as a
+ * 16-character lowercase hex string.
+ *
+ * We split the 64-bit state into two 32-bit halves (high, low) and apply
+ * the FNV-1a algorithm byte-by-byte: xor then multiply by the prime.
+ */
+export function hashBytes(data) {
+    let high = FNV_OFFSET_HIGH;
+    let low = FNV_OFFSET_LOW;
+    for (let i = 0; i < data.length; i++) {
+        // XOR the byte into the low 32 bits of the hash state
+        low ^= data[i];
+        // Multiply the 64-bit state by the 64-bit prime 0x00000100_000001b3.
+        //
+        // The prime has two non-zero components:
+        //   - 0x000001b3 in the low word
+        //   - 0x100 that shifts the old low word into the high word
+        //
+        // Full product (only lower 64 bits kept):
+        //   new_low  = (low * 0x1b3) & 0xFFFFFFFF
+        //   new_high = (high * 0x1b3) + (low * 0x100) + carry_from_low_multiply
+        // Split low into 16-bit halves for precise integer multiplication.
+        const a = low & 0xFFFF;
+        const b = (low >>> 16) & 0xFFFF;
+        const aTimesPrime = a * FNV_PRIME_LOW;
+        const bTimesPrime = b * FNV_PRIME_LOW;
+        const newLowLo = aTimesPrime & 0xFFFF;
+        const mid = (aTimesPrime >>> 16) + (bTimesPrime & 0xFFFF);
+        const newLowHi = mid & 0xFFFF;
+        const carry = (mid >>> 16) + (bTimesPrime >>> 16);
+        const newLow = ((newLowHi << 16) | newLowLo) >>> 0;
+        // high word contribution:
+        //   high * prime_low   (only lower 32 bits matter)
+        // + low  * 0x100       (the prime's high component shifts low into high)
+        // + carry              (from the low multiplication above)
+        const newHigh = ((Math.imul(high, FNV_PRIME_LOW) + Math.imul(low, FNV_PRIME_HIGH_BYTE << 8) + carry) |
+            0) >>>
+            0;
+        low = newLow;
+        high = newHigh;
+    }
+    const highHex = high.toString(16).padStart(8, '0');
+    const lowHex = low.toString(16).padStart(8, '0');
+    return highHex + lowHex;
+}
+// ---------------------------------------------------------------------------
+// MemoryBlobStore
+// ---------------------------------------------------------------------------
+export class MemoryBlobStore {
+    blobs = new Map();
+    async get(hash) {
+        const data = this.blobs.get(hash);
+        if (!data)
+            return null;
+        // Return a copy so callers cannot mutate internal state.
+        return new Uint8Array(data);
+    }
+    async put(data) {
+        const hash = hashBytes(data);
+        if (!this.blobs.has(hash)) {
+            // Store a copy so the caller cannot mutate what we hold.
+            this.blobs.set(hash, new Uint8Array(data));
+        }
+        return hash;
+    }
+    async delete(hash) {
+        this.blobs.delete(hash);
+    }
+    async has(hash) {
+        return this.blobs.has(hash);
+    }
+}

package/dist/substrate/lifo/kernel/storage/ContentStore.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Synchronous, in-memory content-addressable store with LRU eviction.
+ *
+ * The VFS API is fully synchronous, so we need a sync cache for file content.
+ * Large files (>= CHUNK_THRESHOLD) are split into fixed-size chunks and stored
+ * here, keeping INodes lightweight (metadata-only, no inline data).
+ *
+ * The LRU eviction removes least-recently-accessed entries when the total
+ * stored bytes exceed the configured budget.
+ */
+/** Files at or above this size are chunked rather than stored inline.
+ *  Set high to avoid LRU eviction silently losing file data during npm install
+ *  (many packages installed back-to-back can exceed the ContentStore budget). */
+export declare const CHUNK_THRESHOLD: number;
+/** Size of each chunk for large files. */
+export declare const CHUNK_SIZE: number;
+export interface ChunkRef {
+    hash: string;
+    size: number;
+}
+export declare class ContentStore {
+    private cache;
+    private accessCounter;
+    private totalBytes;
+    private maxBytes;
+    constructor(maxBytes?: number);
+    /** Retrieve a blob by hash. Returns null if not in cache. */
+    get(hash: string): Uint8Array | null;
+    /** Store a blob. Returns its content hash. Deduplicates by hash. */
+    put(data: Uint8Array): string;
+    /** Remove a blob from the cache. */
+    delete(hash: string): void;
+    /** Check if a hash exists in the cache. */
+    has(hash: string): boolean;
+    /** Current total bytes in cache. */
+    get size(): number;
+    /** Number of entries in cache. */
+    get count(): number;
+    /**
+     * Split data into chunks, store each, and return the chunk manifest.
+     */
+    storeChunked(data: Uint8Array): ChunkRef[];
+    /**
+     * Reassemble data from a chunk manifest.
+     * Returns null if any chunk is missing from cache.
+     */
+    loadChunked(chunks: ChunkRef[]): Uint8Array | null;
+    /**
+     * Remove all chunks in a manifest from the cache.
+     */
+    deleteChunked(chunks: ChunkRef[]): void;
+    private evict;
+}
+//# sourceMappingURL=ContentStore.d.ts.map

package/dist/substrate/lifo/kernel/storage/ContentStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContentStore.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/kernel/storage/ContentStore.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAMH;;iFAEiF;AACjF,eAAO,MAAM,eAAe,QAAmB,CAAC;AAEhD,0CAA0C;AAC1C,eAAO,MAAM,UAAU,QAAa,CAAC;AAIrC,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AASD,qBAAa,YAAY;IACvB,OAAO,CAAC,KAAK,CAAiC;IAC9C,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,QAAQ,CAAS;gBAEb,QAAQ,GAAE,MAAyB;IAI/C,6DAA6D;IAC7D,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI;IAOpC,oEAAoE;IACpE,GAAG,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM;IAY7B,oCAAoC;IACpC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAQ1B,2CAA2C;IAC3C,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI1B,oCAAoC;IACpC,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,kCAAkC;IAClC,IAAI,KAAK,IAAI,MAAM,CAElB;IAID;;OAEG;IACH,YAAY,CAAC,IAAI,EAAE,UAAU,GAAG,QAAQ,EAAE;IAW1C;;;OAGG;IACH,WAAW,CAAC,MAAM,EAAE,QAAQ,EAAE,GAAG,UAAU,GAAG,IAAI;IAalD;;OAEG;IACH,aAAa,CAAC,MAAM,EAAE,QAAQ,EAAE,GAAG,IAAI;IAQvC,OAAO,CAAC,KAAK;CAad"}

package/dist/substrate/lifo/kernel/storage/ContentStore.js

@@ -0,0 +1,120 @@
+/**
+ * Synchronous, in-memory content-addressable store with LRU eviction.
+ *
+ * The VFS API is fully synchronous, so we need a sync cache for file content.
+ * Large files (>= CHUNK_THRESHOLD) are split into fixed-size chunks and stored
+ * here, keeping INodes lightweight (metadata-only, no inline data).
+ *
+ * The LRU eviction removes least-recently-accessed entries when the total
+ * stored bytes exceed the configured budget.
+ */
+import { hashBytes } from './BlobStore.js';
+// ─── Constants ───
+/** Files at or above this size are chunked rather than stored inline.
+ *  Set high to avoid LRU eviction silently losing file data during npm install
+ *  (many packages installed back-to-back can exceed the ContentStore budget). */
+export const CHUNK_THRESHOLD = 50 * 1024 * 1024; // 50 MB
+/** Size of each chunk for large files. */
+export const CHUNK_SIZE = 256 * 1024; // 256 KB
+export class ContentStore {
+    cache = new Map();
+    accessCounter = 0;
+    totalBytes = 0;
+    maxBytes;
+    constructor(maxBytes = 64 * 1024 * 1024) {
+        this.maxBytes = maxBytes;
+    }
+    /** Retrieve a blob by hash. Returns null if not in cache. */
+    get(hash) {
+        const entry = this.cache.get(hash);
+        if (!entry)
+            return null;
+        entry.lastAccess = ++this.accessCounter;
+        return entry.data;
+    }
+    /** Store a blob. Returns its content hash. Deduplicates by hash. */
+    put(data) {
+        const hash = hashBytes(data);
+        if (this.cache.has(hash)) {
+            this.cache.get(hash).lastAccess = ++this.accessCounter;
+            return hash;
+        }
+        this.cache.set(hash, { data, lastAccess: ++this.accessCounter });
+        this.totalBytes += data.byteLength;
+        this.evict();
+        return hash;
+    }
+    /** Remove a blob from the cache. */
+    delete(hash) {
+        const entry = this.cache.get(hash);
+        if (entry) {
+            this.totalBytes -= entry.data.byteLength;
+            this.cache.delete(hash);
+        }
+    }
+    /** Check if a hash exists in the cache. */
+    has(hash) {
+        return this.cache.has(hash);
+    }
+    /** Current total bytes in cache. */
+    get size() {
+        return this.totalBytes;
+    }
+    /** Number of entries in cache. */
+    get count() {
+        return this.cache.size;
+    }
+    // ─── Chunking helpers ───
+    /**
+     * Split data into chunks, store each, and return the chunk manifest.
+     */
+    storeChunked(data) {
+        const chunks = [];
+        for (let offset = 0; offset < data.byteLength; offset += CHUNK_SIZE) {
+            const end = Math.min(offset + CHUNK_SIZE, data.byteLength);
+            const chunk = data.subarray(offset, end);
+            const hash = this.put(chunk);
+            chunks.push({ hash, size: chunk.byteLength });
+        }
+        return chunks;
+    }
+    /**
+     * Reassemble data from a chunk manifest.
+     * Returns null if any chunk is missing from cache.
+     */
+    loadChunked(chunks) {
+        const totalSize = chunks.reduce((sum, c) => sum + c.size, 0);
+        const result = new Uint8Array(totalSize);
+        let offset = 0;
+        for (const chunk of chunks) {
+            const data = this.get(chunk.hash);
+            if (!data)
+                return null;
+            result.set(data, offset);
+            offset += chunk.size;
+        }
+        return result;
+    }
+    /**
+     * Remove all chunks in a manifest from the cache.
+     */
+    deleteChunked(chunks) {
+        for (const chunk of chunks) {
+            this.delete(chunk.hash);
+        }
+    }
+    // ─── LRU eviction ───
+    evict() {
+        if (this.totalBytes <= this.maxBytes)
+            return;
+        // Sort entries by lastAccess (oldest first) and evict until under budget
+        const entries = Array.from(this.cache.entries())
+            .sort((a, b) => a[1].lastAccess - b[1].lastAccess);
+        for (const [hash, entry] of entries) {
+            if (this.totalBytes <= this.maxBytes)
+                break;
+            this.totalBytes -= entry.data.byteLength;
+            this.cache.delete(hash);
+        }
+    }
+}

package/dist/substrate/lifo/kernel/storage/index.d.ts

@@ -0,0 +1,6 @@
+export { hashBytes } from './BlobStore.js';
+export type { BlobStore } from './BlobStore.js';
+export { MemoryBlobStore } from './BlobStore.js';
+export { ContentStore, CHUNK_THRESHOLD, CHUNK_SIZE } from './ContentStore.js';
+export type { ChunkRef } from './ContentStore.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/substrate/lifo/kernel/storage/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/kernel/storage/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,YAAY,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC9E,YAAY,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/substrate/lifo/kernel/storage/index.js

@@ -0,0 +1,3 @@
+export { hashBytes } from './BlobStore.js';
+export { MemoryBlobStore } from './BlobStore.js';
+export { ContentStore, CHUNK_THRESHOLD, CHUNK_SIZE } from './ContentStore.js';

package/dist/substrate/lifo/kernel/unit-parser.d.ts

@@ -0,0 +1,22 @@
+/**
+ * INI-style unit file parser for systemd-like service definitions.
+ */
+export interface UnitFile {
+    Unit: {
+        Description?: string;
+    };
+    Service: {
+        ExecStart?: string;
+        ExecStop?: string;
+        Type?: 'simple' | 'oneshot';
+        Restart?: 'no' | 'always' | 'on-failure';
+        RestartSec?: number;
+        Environment?: Record<string, string>;
+        WorkingDirectory?: string;
+    };
+    Install: {
+        WantedBy?: string;
+    };
+}
+export declare function parseUnitFile(content: string): UnitFile;
+//# sourceMappingURL=unit-parser.d.ts.map

package/dist/substrate/lifo/kernel/unit-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unit-parser.d.ts","sourceRoot":"","sources":["../../../../src/substrate/lifo/kernel/unit-parser.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE;QACJ,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB,CAAC;IACF,OAAO,EAAE;QACP,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,IAAI,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;QAC5B,OAAO,CAAC,EAAE,IAAI,GAAG,QAAQ,GAAG,YAAY,CAAC;QACzC,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACrC,gBAAgB,CAAC,EAAE,MAAM,CAAC;KAC3B,CAAC;IACF,OAAO,EAAE;QACP,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC;CACH;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,QAAQ,CAwEvD"}

package/dist/substrate/lifo/kernel/unit-parser.js

@@ -0,0 +1,80 @@
+/**
+ * INI-style unit file parser for systemd-like service definitions.
+ */
+export function parseUnitFile(content) {
+    const unit = {
+        Unit: {},
+        Service: {},
+        Install: {},
+    };
+    let currentSection = null;
+    for (const raw of content.split('\n')) {
+        const line = raw.trim();
+        if (!line || line.startsWith('#') || line.startsWith(';'))
+            continue;
+        const sectionMatch = line.match(/^\[(\w+)\]$/);
+        if (sectionMatch) {
+            const name = sectionMatch[1];
+            if (name in unit) {
+                currentSection = name;
+            }
+            continue;
+        }
+        if (!currentSection)
+            continue;
+        const eqIdx = line.indexOf('=');
+        if (eqIdx === -1)
+            continue;
+        const key = line.slice(0, eqIdx).trim();
+        const value = line.slice(eqIdx + 1).trim();
+        switch (currentSection) {
+            case 'Unit':
+                if (key === 'Description')
+                    unit.Unit.Description = value;
+                break;
+            case 'Service':
+                switch (key) {
+                    case 'ExecStart':
+                        unit.Service.ExecStart = value;
+                        break;
+                    case 'ExecStop':
+                        unit.Service.ExecStop = value;
+                        break;
+                    case 'Type':
+                        if (value === 'simple' || value === 'oneshot')
+                            unit.Service.Type = value;
+                        break;
+                    case 'Restart':
+                        if (value === 'no' || value === 'always' || value === 'on-failure')
+                            unit.Service.Restart = value;
+                        break;
+                    case 'RestartSec':
+                        unit.Service.RestartSec = parseInt(value, 10) || 0;
+                        break;
+                    case 'Environment': {
+                        if (!unit.Service.Environment)
+                            unit.Service.Environment = {};
+                        // Parse KEY=VALUE pairs (space-separated)
+                        for (const pair of value.split(/\s+/)) {
+                            const pairEq = pair.indexOf('=');
+                            if (pairEq !== -1) {
+                                const k = pair.slice(0, pairEq);
+                                const v = pair.slice(pairEq + 1).replace(/^"|"$/g, '');
+                                unit.Service.Environment[k] = v;
+                            }
+                        }
+                        break;
+                    }
+                    case 'WorkingDirectory':
+                        unit.Service.WorkingDirectory = value;
+                        break;
+                }
+                break;
+            case 'Install':
+                if (key === 'WantedBy')
+                    unit.Install.WantedBy = value;
+                break;
+        }
+    }
+    return unit;
+}

package/dist/substrate/lifo/kernel/vfs/VFS.d.ts

@@ -0,0 +1,99 @@
+import { INode, Stat, Dirent, VirtualProvider, MountProvider } from './types.js';
+import type { VFSWatchListener } from './types.js';
+import { ContentStore } from '../storage/ContentStore.js';
+import type { VfsCred } from '../../../../runtime/os-contracts.js';
+export declare class VFS {
+    private root;
+    /**
+     * Mount table -- kept sorted longest-prefix-first so that the first match
+     * during lookup is always the most specific.
+     */
+    private mounts;
+    private emitter;
+    onChange?: () => void;
+    /** Content store for chunked large files. Optional -- without it all data stays inline. */
+    readonly contentStore: ContentStore;
+    private cred?;
+    constructor(contentStore?: ContentStore);
+    as(cred: VfsCred): VFS;
+    watch(listener: VFSWatchListener): () => void;
+    watch(path: string, listener: VFSWatchListener): () => void;
+    private notify;
+    /**
+     * Mount a provider at an arbitrary path.
+     * The path is normalised to an absolute path (e.g. "/mnt/project").
+     */
+    mount(path: string, provider: VirtualProvider | MountProvider): void;
+    /**
+     * Unmount the provider at the given path.
+     */
+    unmount(path: string): void;
+    /**
+     * Backward-compatible alias for `mount`.
+     * Previously the only way to register a VirtualProvider at a root-level prefix.
+     */
+    registerProvider(prefix: string, provider: VirtualProvider): void;
+    getRoot(): INode;
+    loadFromSerialized(root: INode): void;
+    /**
+     * `provider` is derived per call — a credentialed VFS hands back a fresh
+     * `as(cred)` view every time — so it is never a stable identity. `entry` is
+     * the mount itself and is what "are these two paths on the same filesystem"
+     * has to compare.
+     */
+    private getProvider;
+    private createNode;
+    private resolveNode;
+    private resolveParent;
+    private toAbsolute;
+    readFile(path: string): Uint8Array;
+    readFileString(path: string): string;
+    writeFile(path: string, content: string | Uint8Array): void;
+    /**
+     * Store file content -- inline for small files, chunked for large files.
+     */
+    private applyFileContent;
+    /**
+     * Read at most `length` bytes at `offset`. Short reads are legal; an empty
+     * result means EOF. Streams (`/dev/*`) and chunked backing stores serve the
+     * slice directly, so bounded readers never materialise a whole file.
+     */
+    readRange(path: string, offset: number, length: number): Uint8Array;
+    /**
+     * Write `bytes` at `offset`, growing the file (zero-filling any gap) as
+     * needed. This is the single write primitive behind sequential writers —
+     * shell redirections, `dd`, and appends all advance an offset through it
+     * instead of rewriting the file per chunk.
+     */
+    writeRange(path: string, offset: number, bytes: Uint8Array): void;
+    /** Shrink or zero-extend a file to exactly `size` bytes. */
+    truncate(path: string, size: number): void;
+    private mountProvider;
+    /**
+     * Replace a file's bytes with `transform(current)`. The read-modify-write
+     * shape is what a backing store without positional writes forces; providers
+     * that do have them never reach here.
+     */
+    private rewriteFile;
+    appendFile(path: string, content: string | Uint8Array): void;
+    exists(path: string): boolean;
+    access(path: string, mode: number): void;
+    stat(path: string): Stat;
+    unlink(path: string): void;
+    rename(oldPath: string, newPath: string): void;
+    copyFile(src: string, dest: string): void;
+    chmod(path: string, mode: number): void;
+    chown(path: string, uid: number | null, gid: number | null): void;
+    touch(path: string): void;
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+    }): void;
+    rmdir(path: string): void;
+    readdir(path: string): Dirent[];
+    readdirStat(path: string): Array<Dirent & Stat>;
+    /**
+     * Recursively remove a directory and all its contents.
+     */
+    rmdirRecursive(path: string): void;
+}
+//# sourceMappingURL=VFS.d.ts.map

package/dist/substrate/lifo/kernel/vfs/VFS.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VFS.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/kernel/vfs/VFS.ts"],"names":[],"mappings":"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"}