@nimbus-sh/core 0.1.0

package/dist/substrate/lifo/kernel/vfs/providers/DevProvider.d.ts

@@ -0,0 +1,21 @@
+import type { MountProvider, Stat, Dirent } from '../types.js';
+export declare class DevProvider implements MountProvider {
+    private norm;
+    private node;
+    readFile(subpath: string): Uint8Array;
+    readFileString(subpath: string): string;
+    readRange(subpath: string, _offset: number, length: number): Uint8Array;
+    writeFile(subpath: string, content: string | Uint8Array): void;
+    writeRange(subpath: string, _offset: number, bytes: Uint8Array): void;
+    truncate(subpath: string, _size: number): void;
+    exists(subpath: string): boolean;
+    stat(subpath: string): Stat;
+    readdir(subpath: string): Dirent[];
+    unlink(subpath: string): void;
+    mkdir(subpath: string): void;
+    rmdir(subpath: string): void;
+    rename(oldSubpath: string): void;
+    copyFile(srcSubpath: string): void;
+    isDirectory(subpath: string): boolean;
+}
+//# sourceMappingURL=DevProvider.d.ts.map

package/dist/substrate/lifo/kernel/vfs/providers/DevProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DevProvider.d.ts","sourceRoot":"","sources":["../../../../../../src/substrate/lifo/kernel/vfs/providers/DevProvider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAwE/D,qBAAa,WAAY,YAAW,aAAa;IAC/C,OAAO,CAAC,IAAI;IAIZ,OAAO,CAAC,IAAI;IAOZ,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU;IAcrC,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAIvC,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,UAAU;IAQvE,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI;IAK9D,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,IAAI;IAIrE,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAK9C,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAKhC,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAS3B,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE;IASlC,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAK7B,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAI5B,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAI5B,MAAM,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAIhC,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAIlC,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;CAGtC"}

package/dist/substrate/lifo/kernel/vfs/providers/DevProvider.js

@@ -0,0 +1,137 @@
+import { VFSError, ErrorCode, S_IFCHR, S_IFDIR } from '../types.js';
+/**
+ * DevProvider — the character devices mounted at `/dev`.
+ *
+ * Device nodes are not files with contents; they are byte sources and sinks.
+ * That distinction is carried by two things and nothing else:
+ *
+ *   - `stat().mode` sets `S_IFCHR`, so `ls -l` renders `crw-rw-rw-` and tools
+ *     can tell a device from a regular file. Size is 0, as on real Unix.
+ *   - `readRange()` generates the requested bytes on demand, so a device has
+ *     no content ceiling — the caller's bound is the only bound.
+ *
+ * `readFile()` is a whole-file read with no bound. On a device that produces
+ * bytes forever that request cannot be answered, so it fails loudly instead
+ * of silently handing back an arbitrary prefix. Bounded readers (`head -c N`,
+ * `dd count=N`, shell redirections) go through `readRange` and work.
+ */
+const DEV_MODE = S_IFCHR | 0o666;
+const DIR_MODE = S_IFDIR | 0o755;
+/**
+ * Largest buffer a single `readRange` will materialise. Returning fewer bytes
+ * than asked for is ordinary read(2) behaviour, so callers already loop; this
+ * just keeps one call from allocating an unbounded buffer.
+ */
+const MAX_DEVICE_READ = 1024 * 1024;
+/** `crypto.getRandomValues` rejects requests larger than this. */
+const RANDOM_FILL_CHUNK = 65536;
+const discard = () => { };
+function fillRandom(out) {
+    for (let i = 0; i < out.length; i += RANDOM_FILL_CHUNK) {
+        crypto.getRandomValues(out.subarray(i, Math.min(out.length, i + RANDOM_FILL_CHUNK)));
+    }
+}
+// Uint8Array is born zeroed, so /dev/zero and /dev/full need no fill body —
+// they only need to declare that they produce bytes forever.
+const zeros = () => { };
+const DEVICES = new Map([
+    ['null', { unbounded: false, write: discard }],
+    ['zero', { unbounded: true, fill: zeros, write: discard }],
+    ['full', {
+            unbounded: true,
+            fill: zeros,
+            write: () => { throw new VFSError(ErrorCode.EINVAL, 'ENOSPC: no space left on device'); },
+        }],
+    ['random', { unbounded: true, fill: fillRandom, write: discard }],
+    ['urandom', { unbounded: true, fill: fillRandom, write: discard }],
+    // The standard-stream nodes exist so `test -e` and `ls` see them. The shell
+    // resolves `/dev/stdin`, `/dev/stdout` and `/dev/stderr` to the invoking
+    // process's own descriptors before a redirection ever reaches this provider.
+    ['stdin', { unbounded: false, write: discard }],
+    ['stdout', { unbounded: false, write: discard }],
+    ['stderr', { unbounded: false, write: discard }],
+    ['tty', { unbounded: false, write: discard }],
+]);
+export class DevProvider {
+    norm(subpath) {
+        return subpath.replace(/^\/+/, '').replace(/\/+$/, '');
+    }
+    node(subpath) {
+        const name = this.norm(subpath);
+        const node = DEVICES.get(name);
+        if (!node)
+            throw new VFSError(ErrorCode.ENOENT, `'/dev/${name}': no such device`);
+        return node;
+    }
+    readFile(subpath) {
+        if (this.norm(subpath) === '') {
+            throw new VFSError(ErrorCode.EISDIR, `'/dev': is a directory`);
+        }
+        const node = this.node(subpath);
+        if (node.unbounded) {
+            throw new VFSError(ErrorCode.EINVAL, `'/dev/${this.norm(subpath)}': character device produces bytes without end — read a bounded slice (head -c N, dd count=N)`);
+        }
+        return new Uint8Array(0);
+    }
+    readFileString(subpath) {
+        return new TextDecoder().decode(this.readFile(subpath));
+    }
+    readRange(subpath, _offset, length) {
+        const node = this.node(subpath);
+        if (!node.fill)
+            return new Uint8Array(0);
+        const out = new Uint8Array(Math.min(length, MAX_DEVICE_READ));
+        node.fill(out);
+        return out;
+    }
+    writeFile(subpath, content) {
+        const node = this.node(subpath);
+        node.write(typeof content === 'string' ? new TextEncoder().encode(content) : content);
+    }
+    writeRange(subpath, _offset, bytes) {
+        this.node(subpath).write(bytes);
+    }
+    truncate(subpath, _size) {
+        // Devices have no length to set; the node must still exist.
+        this.node(subpath);
+    }
+    exists(subpath) {
+        const name = this.norm(subpath);
+        return name === '' || DEVICES.has(name);
+    }
+    stat(subpath) {
+        const name = this.norm(subpath);
+        if (name === '') {
+            return { type: 'directory', size: DEVICES.size, ctime: 0, mtime: 0, mode: DIR_MODE };
+        }
+        this.node(subpath);
+        return { type: 'file', size: 0, ctime: 0, mtime: 0, mode: DEV_MODE };
+    }
+    readdir(subpath) {
+        const name = this.norm(subpath);
+        if (name !== '') {
+            this.node(subpath);
+            throw new VFSError(ErrorCode.ENOTDIR, `'/dev/${name}': not a directory`);
+        }
+        return [...DEVICES.keys()].map((device) => ({ name: device, type: 'file' }));
+    }
+    unlink(subpath) {
+        this.node(subpath);
+        throw new VFSError(ErrorCode.EINVAL, `'/dev/${this.norm(subpath)}': operation not permitted`);
+    }
+    mkdir(subpath) {
+        throw new VFSError(ErrorCode.EINVAL, `'/dev/${this.norm(subpath)}': read-only filesystem`);
+    }
+    rmdir(subpath) {
+        throw new VFSError(ErrorCode.EINVAL, `'/dev/${this.norm(subpath)}': read-only filesystem`);
+    }
+    rename(oldSubpath) {
+        throw new VFSError(ErrorCode.EINVAL, `'/dev/${this.norm(oldSubpath)}': read-only filesystem`);
+    }
+    copyFile(srcSubpath) {
+        throw new VFSError(ErrorCode.EINVAL, `'/dev/${this.norm(srcSubpath)}': read-only filesystem`);
+    }
+    isDirectory(subpath) {
+        return this.norm(subpath) === '';
+    }
+}

package/dist/substrate/lifo/kernel/vfs/providers/NativeFsProvider.d.ts

@@ -0,0 +1,63 @@
+import type { MountProvider, Stat, Dirent } from '../types.js';
+/**
+ * Minimal interface for the subset of Node.js `fs` sync methods we need.
+ * Consumers pass this in so we avoid a hard dependency on `node:fs`.
+ */
+export interface NativeFsModule {
+    readFileSync(path: string): Uint8Array;
+    writeFileSync(path: string, data: string | Uint8Array): void;
+    existsSync(path: string): boolean;
+    statSync(path: string): {
+        isFile(): boolean;
+        isDirectory(): boolean;
+        size: number;
+        mtimeMs: number;
+        ctimeMs: number;
+        mode: number;
+    };
+    readdirSync(path: string, options: {
+        withFileTypes: true;
+    }): Array<{
+        name: string;
+        isFile(): boolean;
+        isDirectory(): boolean;
+    }>;
+    unlinkSync(path: string): void;
+    mkdirSync(path: string, options?: {
+        recursive?: boolean;
+    }): void;
+    rmdirSync(path: string): void;
+    renameSync(oldPath: string, newPath: string): void;
+    copyFileSync(src: string, dest: string): void;
+}
+/**
+ * A MountProvider that delegates to a native filesystem via sync Node.js APIs.
+ *
+ * All subpaths are sandboxed to `rootPath` -- any attempt to escape via `..`
+ * is rejected with EINVAL.
+ */
+export declare class NativeFsProvider implements MountProvider {
+    private rootPath;
+    private fs;
+    private readOnly;
+    constructor(rootPath: string, fsModule: NativeFsModule, options?: {
+        readOnly?: boolean;
+    });
+    private resolveSafe;
+    private assertWritable;
+    readFile(subpath: string): Uint8Array;
+    readFileString(subpath: string): string;
+    exists(subpath: string): boolean;
+    stat(subpath: string): Stat;
+    readdir(subpath: string): Dirent[];
+    writeFile(subpath: string, content: string | Uint8Array): void;
+    unlink(subpath: string): void;
+    mkdir(subpath: string, options?: {
+        recursive?: boolean;
+    }): void;
+    rmdir(subpath: string): void;
+    rename(oldSubpath: string, newSubpath: string): void;
+    copyFile(srcSubpath: string, destSubpath: string): void;
+    private wrapError;
+}
+//# sourceMappingURL=NativeFsProvider.d.ts.map

package/dist/substrate/lifo/kernel/vfs/providers/NativeFsProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativeFsProvider.d.ts","sourceRoot":"","sources":["../../../../../../src/substrate/lifo/kernel/vfs/providers/NativeFsProvider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAG/D;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC;IACvC,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAAC;IAC7D,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAClC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG;QAAE,MAAM,IAAI,OAAO,CAAC;QAAC,WAAW,IAAI,OAAO,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACpI,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE;QAAE,aAAa,EAAE,IAAI,CAAA;KAAE,GAAG,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,IAAI,OAAO,CAAC;QAAC,WAAW,IAAI,OAAO,CAAA;KAAE,CAAC,CAAC;IAChI,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,CAAC;IACjE,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACnD,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/C;AAED;;;;;GAKG;AACH,qBAAa,gBAAiB,YAAW,aAAa;IACpD,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,EAAE,CAAiB;IAC3B,OAAO,CAAC,QAAQ,CAAU;gBAEd,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,EAAE,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE;IAWxF,OAAO,CAAC,WAAW;IAsBnB,OAAO,CAAC,cAAc;IAQtB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU;IASrC,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAKvC,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAKhC,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAgB3B,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE;IAelC,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI;IAU9D,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAU7B,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI;IAU/D,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAU5B,MAAM,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI;IAWpD,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI;IAavD,OAAO,CAAC,SAAS;CAWlB"}

package/dist/substrate/lifo/kernel/vfs/providers/NativeFsProvider.js

@@ -0,0 +1,175 @@
+import { VFSError, ErrorCode } from '../types.js';
+/**
+ * A MountProvider that delegates to a native filesystem via sync Node.js APIs.
+ *
+ * All subpaths are sandboxed to `rootPath` -- any attempt to escape via `..`
+ * is rejected with EINVAL.
+ */
+export class NativeFsProvider {
+    rootPath;
+    fs;
+    readOnly;
+    constructor(rootPath, fsModule, options) {
+        // Normalize: strip trailing slash unless it's the root itself
+        this.rootPath = rootPath.endsWith('/') && rootPath.length > 1
+            ? rootPath.slice(0, -1)
+            : rootPath;
+        this.fs = fsModule;
+        this.readOnly = options?.readOnly ?? false;
+    }
+    // ─── Path sandboxing ───
+    resolveSafe(subpath) {
+        // Normalize the subpath: remove leading slash, resolve . and ..
+        const clean = subpath.startsWith('/') ? subpath.slice(1) : subpath;
+        const parts = clean.split('/').filter(Boolean);
+        const resolved = [];
+        for (const part of parts) {
+            if (part === '.')
+                continue;
+            if (part === '..') {
+                if (resolved.length === 0) {
+                    throw new VFSError(ErrorCode.EINVAL, `path '${subpath}' escapes mount root`);
+                }
+                resolved.pop();
+            }
+            else {
+                resolved.push(part);
+            }
+        }
+        const relative = resolved.join('/');
+        return relative ? `${this.rootPath}/${relative}` : this.rootPath;
+    }
+    assertWritable() {
+        if (this.readOnly) {
+            throw new VFSError(ErrorCode.EINVAL, 'filesystem is mounted read-only');
+        }
+    }
+    // ─── Read operations ───
+    readFile(subpath) {
+        const fullPath = this.resolveSafe(subpath);
+        try {
+            return this.fs.readFileSync(fullPath);
+        }
+        catch (err) {
+            throw this.wrapError(err, subpath);
+        }
+    }
+    readFileString(subpath) {
+        const data = this.readFile(subpath);
+        return new TextDecoder().decode(data);
+    }
+    exists(subpath) {
+        const fullPath = this.resolveSafe(subpath);
+        return this.fs.existsSync(fullPath);
+    }
+    stat(subpath) {
+        const fullPath = this.resolveSafe(subpath);
+        try {
+            const s = this.fs.statSync(fullPath);
+            return {
+                type: s.isDirectory() ? 'directory' : 'file',
+                size: s.size,
+                ctime: Math.floor(s.ctimeMs),
+                mtime: Math.floor(s.mtimeMs),
+                mode: s.mode,
+            };
+        }
+        catch (err) {
+            throw this.wrapError(err, subpath);
+        }
+    }
+    readdir(subpath) {
+        const fullPath = this.resolveSafe(subpath);
+        try {
+            const entries = this.fs.readdirSync(fullPath, { withFileTypes: true });
+            return entries.map((e) => ({
+                name: e.name,
+                type: e.isDirectory() ? 'directory' : 'file',
+            }));
+        }
+        catch (err) {
+            throw this.wrapError(err, subpath);
+        }
+    }
+    // ─── Write operations ───
+    writeFile(subpath, content) {
+        this.assertWritable();
+        const fullPath = this.resolveSafe(subpath);
+        try {
+            this.fs.writeFileSync(fullPath, content);
+        }
+        catch (err) {
+            throw this.wrapError(err, subpath);
+        }
+    }
+    unlink(subpath) {
+        this.assertWritable();
+        const fullPath = this.resolveSafe(subpath);
+        try {
+            this.fs.unlinkSync(fullPath);
+        }
+        catch (err) {
+            throw this.wrapError(err, subpath);
+        }
+    }
+    mkdir(subpath, options) {
+        this.assertWritable();
+        const fullPath = this.resolveSafe(subpath);
+        try {
+            this.fs.mkdirSync(fullPath, options);
+        }
+        catch (err) {
+            throw this.wrapError(err, subpath);
+        }
+    }
+    rmdir(subpath) {
+        this.assertWritable();
+        const fullPath = this.resolveSafe(subpath);
+        try {
+            this.fs.rmdirSync(fullPath);
+        }
+        catch (err) {
+            throw this.wrapError(err, subpath);
+        }
+    }
+    rename(oldSubpath, newSubpath) {
+        this.assertWritable();
+        const oldFull = this.resolveSafe(oldSubpath);
+        const newFull = this.resolveSafe(newSubpath);
+        try {
+            this.fs.renameSync(oldFull, newFull);
+        }
+        catch (err) {
+            throw this.wrapError(err, newSubpath);
+        }
+    }
+    copyFile(srcSubpath, destSubpath) {
+        this.assertWritable();
+        const srcFull = this.resolveSafe(srcSubpath);
+        const destFull = this.resolveSafe(destSubpath);
+        try {
+            this.fs.copyFileSync(srcFull, destFull);
+        }
+        catch (err) {
+            throw this.wrapError(err, destSubpath);
+        }
+    }
+    // ─── Error mapping ───
+    wrapError(err, subpath) {
+        if (err instanceof VFSError)
+            return err;
+        const msg = err instanceof Error ? err.message : String(err);
+        const code = err?.code;
+        if (code === 'ENOENT')
+            return new VFSError(ErrorCode.ENOENT, `'${subpath}': ${msg}`);
+        if (code === 'EEXIST')
+            return new VFSError(ErrorCode.EEXIST, `'${subpath}': ${msg}`);
+        if (code === 'EISDIR')
+            return new VFSError(ErrorCode.EISDIR, `'${subpath}': ${msg}`);
+        if (code === 'ENOTDIR')
+            return new VFSError(ErrorCode.ENOTDIR, `'${subpath}': ${msg}`);
+        if (code === 'ENOTEMPTY')
+            return new VFSError(ErrorCode.ENOTEMPTY, `'${subpath}': ${msg}`);
+        return new VFSError(ErrorCode.EINVAL, `'${subpath}': ${msg}`);
+    }
+}

package/dist/substrate/lifo/kernel/vfs/providers/ProcProvider.d.ts

@@ -0,0 +1,14 @@
+import type { VirtualProvider, Stat, Dirent } from '../types.js';
+export declare class ProcProvider implements VirtualProvider {
+    private generators;
+    constructor();
+    private isNetPath;
+    private getNetInfo;
+    private generate;
+    readFile(subpath: string): Uint8Array;
+    readFileString(subpath: string): string;
+    exists(subpath: string): boolean;
+    stat(subpath: string): Stat;
+    readdir(subpath: string): Dirent[];
+}
+//# sourceMappingURL=ProcProvider.d.ts.map

package/dist/substrate/lifo/kernel/vfs/providers/ProcProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProcProvider.d.ts","sourceRoot":"","sources":["../../../../../../src/substrate/lifo/kernel/vfs/providers/ProcProvider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAIjE,qBAAa,YAAa,YAAW,eAAe;IAClD,OAAO,CAAC,UAAU,CAAmC;;IAqDrD,OAAO,CAAC,SAAS;IAIjB,OAAO,CAAC,UAAU;IAgBlB,OAAO,CAAC,QAAQ;IAehB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU;IAIrC,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAIvC,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAOhC,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAmB3B,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE;CAgBnC"}

package/dist/substrate/lifo/kernel/vfs/providers/ProcProvider.js

@@ -0,0 +1,126 @@
+import { VFSError, ErrorCode } from '../types.js';
+import { encode } from '../../../utils/encoding.js';
+export class ProcProvider {
+    generators = new Map();
+    constructor() {
+        this.generators.set('cpuinfo', () => {
+            const cores = typeof navigator !== 'undefined'
+                ? navigator.hardwareConcurrency ?? 1
+                : 1;
+            const lines = [];
+            for (let i = 0; i < cores; i++) {
+                lines.push(`processor\t: ${i}`);
+                lines.push(`model name\t: Browser Virtual CPU`);
+                lines.push(`cpu cores\t: ${cores}`);
+                lines.push('');
+            }
+            return lines.join('\n');
+        });
+        this.generators.set('meminfo', () => {
+            const perf = typeof performance !== 'undefined' ? performance : null;
+            const memory = perf?.memory;
+            if (memory) {
+                const totalKB = Math.floor(memory.jsHeapSizeLimit / 1024);
+                const usedKB = Math.floor(memory.usedJSHeapSize / 1024);
+                const freeKB = totalKB - usedKB;
+                return [
+                    `MemTotal:       ${totalKB} kB`,
+                    `MemFree:        ${freeKB} kB`,
+                    `MemUsed:        ${usedKB} kB`,
+                    `HeapTotal:      ${Math.floor(memory.totalJSHeapSize / 1024)} kB`,
+                    '',
+                ].join('\n');
+            }
+            return [
+                'MemTotal:       2097152 kB',
+                'MemFree:        1048576 kB',
+                'MemUsed:        1048576 kB',
+                '',
+            ].join('\n');
+        });
+        this.generators.set('uptime', () => {
+            const seconds = typeof performance !== 'undefined'
+                ? (performance.now() / 1000).toFixed(2)
+                : '0.00';
+            return `${seconds} ${seconds}\n`;
+        });
+        this.generators.set('version', () => {
+            const ua = typeof navigator !== 'undefined' ? navigator.userAgent : 'Node.js';
+            return `Lifo 1.0.0 (${ua})\n`;
+        });
+    }
+    isNetPath(subpath) {
+        return subpath === '/net' || subpath === '/net/info';
+    }
+    getNetInfo() {
+        const conn = typeof navigator !== 'undefined'
+            ? navigator.connection
+            : undefined;
+        if (conn) {
+            return [
+                `type:          ${conn.type ?? 'unknown'}`,
+                `effectiveType: ${conn.effectiveType ?? 'unknown'}`,
+                `downlink:      ${conn.downlink ?? 0} Mbps`,
+                `rtt:           ${conn.rtt ?? 0} ms`,
+                '',
+            ].join('\n');
+        }
+        return 'Network information not available\n';
+    }
+    generate(subpath) {
+        // Normalize: '/cpuinfo' -> 'cpuinfo'
+        const name = subpath.startsWith('/') ? subpath.slice(1) : subpath;
+        if (name === 'net/info') {
+            return this.getNetInfo();
+        }
+        const gen = this.generators.get(name);
+        if (!gen) {
+            throw new VFSError(ErrorCode.ENOENT, `'/proc${subpath}': no such file`);
+        }
+        return gen();
+    }
+    readFile(subpath) {
+        return encode(this.readFileString(subpath));
+    }
+    readFileString(subpath) {
+        return this.generate(subpath);
+    }
+    exists(subpath) {
+        if (subpath === '/')
+            return true;
+        if (this.isNetPath(subpath))
+            return true;
+        const name = subpath.startsWith('/') ? subpath.slice(1) : subpath;
+        return this.generators.has(name);
+    }
+    stat(subpath) {
+        if (!this.exists(subpath)) {
+            throw new VFSError(ErrorCode.ENOENT, `'/proc${subpath}': no such file`);
+        }
+        if (subpath === '/' || subpath === '/net') {
+            return { type: 'directory', size: 0, ctime: 0, mtime: Date.now(), mode: 0o555 };
+        }
+        const content = this.generate(subpath);
+        return {
+            type: 'file',
+            size: content.length,
+            ctime: 0,
+            mtime: Date.now(),
+            mode: 0o444,
+        };
+    }
+    readdir(subpath) {
+        if (subpath === '/') {
+            const entries = [];
+            for (const name of this.generators.keys()) {
+                entries.push({ name, type: 'file' });
+            }
+            entries.push({ name: 'net', type: 'directory' });
+            return entries;
+        }
+        if (subpath === '/net') {
+            return [{ name: 'info', type: 'file' }];
+        }
+        throw new VFSError(ErrorCode.ENOTDIR, `'/proc${subpath}': not a directory`);
+    }
+}

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

@@ -0,0 +1,117 @@
+import type { VfsCred } from '../../../../runtime/os-contracts.js';
+/**
+ * What a stat can report.
+ *
+ * `symlink` is here because a mounted provider can return one — the durable
+ * filesystem models symlinks — and the in-memory tree simply never produces
+ * it. Leaving it out did not make symlinks go away; it made the one mount
+ * that has them require a cast at every call site.
+ */
+export type FileType = 'file' | 'directory' | 'symlink';
+export type VFSEventType = 'create' | 'modify' | 'delete' | 'rename';
+export interface VFSWatchEvent {
+    type: VFSEventType;
+    path: string;
+    oldPath?: string;
+    fileType: FileType;
+}
+export type VFSWatchListener = (event: VFSWatchEvent) => void;
+export interface ChunkRef {
+    hash: string;
+    size: number;
+}
+export interface INode {
+    type: FileType;
+    name: string;
+    data: Uint8Array;
+    children: Map<string, INode>;
+    ctime: number;
+    mtime: number;
+    mode: number;
+    mime?: string;
+    blobRef?: string;
+    chunks?: ChunkRef[];
+    storedSize?: number;
+}
+/**
+ * `st_mode` file-type bits. `Stat.type` only distinguishes file from
+ * directory, so anything finer — a character device, a symlink — is carried
+ * in the mode, exactly as Unix does it. `ls -l` and `stat` read the leading
+ * type character from here.
+ */
+export declare const S_IFMT = 61440;
+export declare const S_IFREG = 32768;
+export declare const S_IFDIR = 16384;
+export declare const S_IFCHR = 8192;
+export declare const S_IFLNK = 40960;
+/** True for a character device such as `/dev/zero`, which streams rather than stores. */
+export declare function isCharacterDevice(mode: number): boolean;
+/** The `ls -l` type character for a mode, falling back to the coarse `Stat.type`. */
+export declare function fileTypeChar(mode: number, type: FileType): string;
+export interface Stat {
+    type: FileType;
+    size: number;
+    ctime: number;
+    mtime: number;
+    mode: number;
+    uid?: number;
+    gid?: number;
+    mime?: string;
+}
+export interface Dirent {
+    name: string;
+    type: FileType;
+}
+export declare const ErrorCode: {
+    readonly ENOENT: "ENOENT";
+    readonly EEXIST: "EEXIST";
+    readonly ENOTDIR: "ENOTDIR";
+    readonly EISDIR: "EISDIR";
+    readonly ENOTEMPTY: "ENOTEMPTY";
+    readonly EINVAL: "EINVAL";
+    readonly EXDEV: "EXDEV";
+};
+export type ErrorCodeType = (typeof ErrorCode)[keyof typeof ErrorCode];
+export interface VirtualProvider {
+    readFile(subpath: string): Uint8Array;
+    readFileString(subpath: string): string;
+    /**
+     * Read at most `length` bytes at `offset` without materialising the whole
+     * file. Short reads are legal (read(2) semantics) — callers must loop until
+     * they get what they need or an empty result signals EOF. Providers that
+     * cannot serve a slice cheaply omit this; `VFS.readRange` then slices a
+     * whole-file read for them.
+     */
+    readRange?(subpath: string, offset: number, length: number): Uint8Array;
+    writeFile?(subpath: string, content: string | Uint8Array): void;
+    exists(subpath: string): boolean;
+    stat(subpath: string): Stat;
+    readdir(subpath: string): Dirent[];
+    access?(subpath: string, mode: number): void;
+    as?(cred: VfsCred): VirtualProvider;
+}
+export interface MountProvider extends VirtualProvider {
+    writeFile(subpath: string, content: string | Uint8Array): void;
+    /**
+     * Write `bytes` at `offset`, growing the file as needed, without rewriting
+     * the parts of it the range does not touch. Providers that cannot do this
+     * omit it; `VFS.writeRange` then splices via a whole-file read/write.
+     */
+    writeRange?(subpath: string, offset: number, bytes: Uint8Array): void;
+    truncate?(subpath: string, size: number): void;
+    unlink(subpath: string): void;
+    mkdir(subpath: string, options?: {
+        recursive?: boolean;
+    }): void;
+    rmdir(subpath: string): void;
+    rename(oldSubpath: string, newSubpath: string): void;
+    copyFile(srcSubpath: string, destSubpath: string): void;
+    /** Set permission bits. Providers without chmod reject it (read-only fs). */
+    chmod?(subpath: string, mode: number): void;
+    chown?(subpath: string, uid: number | null, gid: number | null): void;
+}
+export declare class VFSError extends Error {
+    code: ErrorCodeType;
+    constructor(code: ErrorCodeType, message: string);
+}
+//# sourceMappingURL=types.d.ts.map

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

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