@nimbus-sh/core 0.1.0

package/dist/substrate/lifo/commands/archive/gunzip.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from '../types.js';
+declare const command: Command;
+export default command;
+//# sourceMappingURL=gunzip.d.ts.map

package/dist/substrate/lifo/commands/archive/gunzip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gunzip.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/commands/archive/gunzip.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAa3C,QAAA,MAAM,OAAO,EAAE,OA+Cd,CAAC;AAEF,eAAe,OAAO,CAAC"}

package/dist/substrate/lifo/commands/archive/gunzip.js

@@ -0,0 +1,58 @@
+import { resolve } from '../../utils/path.js';
+import { decompressGzip } from '../../utils/archive.js';
+import { parseArgs } from '../../utils/args.js';
+import { VFSError } from '../../kernel/vfs/index.js';
+const spec = {
+    keep: { type: 'boolean', short: 'k' },
+    force: { type: 'boolean', short: 'f' },
+    quiet: { type: 'boolean', short: 'q' },
+    help: { type: 'boolean' },
+};
+const command = async (ctx) => {
+    const { flags, positional, unknown } = parseArgs(ctx.args, spec);
+    if (flags.help) {
+        ctx.stdout.write('Usage: gunzip [-kfq] file.gz...\n');
+        ctx.stdout.write('  -k, --keep    keep original file\n');
+        ctx.stdout.write('  -f, --force   overwrite an existing output file\n');
+        ctx.stdout.write('  -q, --quiet   suppress warnings\n');
+        return 0;
+    }
+    if (unknown.length > 0) {
+        ctx.stderr.write(`gunzip: invalid option -- '${unknown[0].replace(/^-+/, '')}'\n`);
+        return 1;
+    }
+    const keep = flags.keep === true;
+    const files = positional;
+    if (files.length === 0) {
+        ctx.stderr.write('gunzip: missing file operand\n');
+        return 1;
+    }
+    let exitCode = 0;
+    for (const file of files) {
+        const path = resolve(ctx.cwd, file);
+        try {
+            if (!path.endsWith('.gz')) {
+                ctx.stderr.write(`gunzip: ${file}: unknown suffix -- ignored\n`);
+                exitCode = 1;
+                continue;
+            }
+            const data = ctx.vfs.readFile(path);
+            const decompressed = await decompressGzip(data);
+            const outPath = path.slice(0, -3);
+            ctx.vfs.writeFile(outPath, decompressed);
+            if (!keep)
+                ctx.vfs.unlink(path);
+        }
+        catch (e) {
+            if (e instanceof VFSError) {
+                ctx.stderr.write(`gunzip: ${file}: ${e.message}\n`);
+                exitCode = 1;
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    return exitCode;
+};
+export default command;

package/dist/substrate/lifo/commands/archive/gzip.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from '../types.js';
+declare const command: Command;
+export default command;
+//# sourceMappingURL=gzip.d.ts.map

package/dist/substrate/lifo/commands/archive/gzip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gzip.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/commands/archive/gzip.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAc3C,QAAA,MAAM,OAAO,EAAE,OA2Dd,CAAC;AAEF,eAAe,OAAO,CAAC"}

package/dist/substrate/lifo/commands/archive/gzip.js

@@ -0,0 +1,73 @@
+import { resolve } from '../../utils/path.js';
+import { compressGzip, decompressGzip } from '../../utils/archive.js';
+import { parseArgs } from '../../utils/args.js';
+import { VFSError } from '../../kernel/vfs/index.js';
+const spec = {
+    keep: { type: 'boolean', short: 'k' },
+    decompress: { type: 'boolean', short: 'd' },
+    force: { type: 'boolean', short: 'f' },
+    quiet: { type: 'boolean', short: 'q' },
+    help: { type: 'boolean' },
+};
+const command = async (ctx) => {
+    const { flags, positional, unknown } = parseArgs(ctx.args, spec);
+    if (flags.help) {
+        ctx.stdout.write('Usage: gzip [-kdfq] file...\n');
+        ctx.stdout.write('  -k, --keep         keep original file\n');
+        ctx.stdout.write('  -d, --decompress   decompress\n');
+        ctx.stdout.write('  -f, --force        overwrite an existing output file\n');
+        ctx.stdout.write('  -q, --quiet        suppress warnings\n');
+        return 0;
+    }
+    // Compression levels are accepted and ignored: the gzip stream this VFS
+    // writes comes from CompressionStream, which exposes no level control.
+    const rejected = unknown.filter((o) => !/^-[1-9]$/.test(o));
+    if (rejected.length > 0) {
+        ctx.stderr.write(`gzip: invalid option -- '${rejected[0].replace(/^-+/, '')}'\n`);
+        return 1;
+    }
+    const keep = flags.keep === true;
+    const decompress = flags.decompress === true;
+    const files = positional;
+    if (files.length === 0) {
+        ctx.stderr.write('gzip: missing file operand\n');
+        return 1;
+    }
+    let exitCode = 0;
+    for (const file of files) {
+        const path = resolve(ctx.cwd, file);
+        try {
+            if (decompress) {
+                if (!path.endsWith('.gz')) {
+                    ctx.stderr.write(`gzip: ${file}: unknown suffix -- ignored\n`);
+                    exitCode = 1;
+                    continue;
+                }
+                const data = ctx.vfs.readFile(path);
+                const decompressed = await decompressGzip(data);
+                const outPath = path.slice(0, -3);
+                ctx.vfs.writeFile(outPath, decompressed);
+                if (!keep)
+                    ctx.vfs.unlink(path);
+            }
+            else {
+                const data = ctx.vfs.readFile(path);
+                const compressed = await compressGzip(data);
+                ctx.vfs.writeFile(path + '.gz', compressed);
+                if (!keep)
+                    ctx.vfs.unlink(path);
+            }
+        }
+        catch (e) {
+            if (e instanceof VFSError) {
+                ctx.stderr.write(`gzip: ${file}: ${e.message}\n`);
+                exitCode = 1;
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    return exitCode;
+};
+export default command;

package/dist/substrate/lifo/commands/archive/tar.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from '../types.js';
+declare const command: Command;
+export default command;
+//# sourceMappingURL=tar.d.ts.map

package/dist/substrate/lifo/commands/archive/tar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tar.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/commands/archive/tar.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAK3C,QAAA,MAAM,OAAO,EAAE,OAqJd,CAAC;AAEF,eAAe,OAAO,CAAC"}

package/dist/substrate/lifo/commands/archive/tar.js

@@ -0,0 +1,158 @@
+import { resolve, dirname } from '../../utils/path.js';
+import { createTar, parseTar, compressGzip, decompressGzip, collectFiles } from '../../utils/archive.js';
+import { VFSError } from '../../kernel/vfs/index.js';
+const command = async (ctx) => {
+    let create = false;
+    let extract = false;
+    let list = false;
+    let gzipFlag = false;
+    let verbose = false;
+    let archiveFile = '';
+    let changeDir = '';
+    const files = [];
+    // Parse args manually (tar uses combined flags like -czf)
+    let i = 0;
+    while (i < ctx.args.length) {
+        const arg = ctx.args[i];
+        if (arg === '--help') {
+            ctx.stdout.write('Usage: tar [-c|-x|-t] [-z] [-v] [-f file] [-C dir] [files...]\n');
+            ctx.stdout.write('  -c   create archive\n');
+            ctx.stdout.write('  -x   extract archive\n');
+            ctx.stdout.write('  -t   list archive contents\n');
+            ctx.stdout.write('  -z   gzip compression\n');
+            ctx.stdout.write('  -v   verbose\n');
+            ctx.stdout.write('  -f   archive file\n');
+            ctx.stdout.write('  -C   change directory\n');
+            return 0;
+        }
+        if (arg.startsWith('-') && arg !== '-') {
+            const chars = arg.slice(1);
+            for (let j = 0; j < chars.length; j++) {
+                switch (chars[j]) {
+                    case 'c':
+                        create = true;
+                        break;
+                    case 'x':
+                        extract = true;
+                        break;
+                    case 't':
+                        list = true;
+                        break;
+                    case 'z':
+                        gzipFlag = true;
+                        break;
+                    case 'v':
+                        verbose = true;
+                        break;
+                    case 'f': {
+                        const rest = chars.slice(j + 1);
+                        archiveFile = rest || ctx.args[++i] || '';
+                        j = chars.length; // break out of inner loop
+                        break;
+                    }
+                    case 'C': {
+                        const rest = chars.slice(j + 1);
+                        changeDir = rest || ctx.args[++i] || '';
+                        j = chars.length;
+                        break;
+                    }
+                    default:
+                        ctx.stderr.write(`tar: unknown option: -${chars[j]}\n`);
+                        return 1;
+                }
+            }
+        }
+        else {
+            files.push(arg);
+        }
+        i++;
+    }
+    const modeCount = [create, extract, list].filter(Boolean).length;
+    if (modeCount === 0) {
+        ctx.stderr.write('tar: must specify one of -c, -x, -t\n');
+        return 1;
+    }
+    if (modeCount > 1) {
+        ctx.stderr.write('tar: conflicting options\n');
+        return 1;
+    }
+    if (!archiveFile) {
+        ctx.stderr.write('tar: -f is required\n');
+        return 1;
+    }
+    const archivePath = resolve(ctx.cwd, archiveFile);
+    const targetDir = changeDir ? resolve(ctx.cwd, changeDir) : ctx.cwd;
+    try {
+        if (create) {
+            if (files.length === 0) {
+                ctx.stderr.write('tar: no files to archive\n');
+                return 1;
+            }
+            const entries = collectFiles(ctx.vfs, targetDir, files);
+            let data = createTar(entries);
+            if (gzipFlag) {
+                data = await compressGzip(data);
+            }
+            ctx.vfs.writeFile(archivePath, data);
+            if (verbose) {
+                for (const entry of entries) {
+                    ctx.stdout.write(`${entry.path}\n`);
+                }
+            }
+        }
+        else if (extract) {
+            let data = ctx.vfs.readFile(archivePath);
+            if (gzipFlag) {
+                data = await decompressGzip(data);
+            }
+            const entries = parseTar(data);
+            // Ensure target dir exists
+            if (changeDir) {
+                try {
+                    ctx.vfs.mkdir(targetDir, { recursive: true });
+                }
+                catch { /* exists */ }
+            }
+            for (const entry of entries) {
+                const entryPath = resolve(targetDir, entry.path);
+                if (entry.type === 'directory') {
+                    try {
+                        ctx.vfs.mkdir(entryPath, { recursive: true });
+                    }
+                    catch { /* exists */ }
+                }
+                else {
+                    // Ensure parent dir exists
+                    const parent = dirname(entryPath);
+                    try {
+                        ctx.vfs.mkdir(parent, { recursive: true });
+                    }
+                    catch { /* exists */ }
+                    ctx.vfs.writeFile(entryPath, entry.data);
+                }
+                if (verbose) {
+                    ctx.stdout.write(`${entry.path}\n`);
+                }
+            }
+        }
+        else if (list) {
+            let data = ctx.vfs.readFile(archivePath);
+            if (gzipFlag) {
+                data = await decompressGzip(data);
+            }
+            const entries = parseTar(data);
+            for (const entry of entries) {
+                ctx.stdout.write(`${entry.path}${entry.type === 'directory' ? '/' : ''}\n`);
+            }
+        }
+    }
+    catch (e) {
+        if (e instanceof VFSError) {
+            ctx.stderr.write(`tar: ${e.message}\n`);
+            return 2;
+        }
+        throw e;
+    }
+    return 0;
+};
+export default command;

package/dist/substrate/lifo/commands/archive/unzip.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from '../types.js';
+declare const command: Command;
+export default command;
+//# sourceMappingURL=unzip.d.ts.map

package/dist/substrate/lifo/commands/archive/unzip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unzip.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/commands/archive/unzip.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAiB3C,QAAA,MAAM,OAAO,EAAE,OAuFd,CAAC;AAOF,eAAe,OAAO,CAAC"}

package/dist/substrate/lifo/commands/archive/unzip.js

@@ -0,0 +1,114 @@
+import { resolve, dirname } from '../../utils/path.js';
+import { parseZip } from '../../utils/archive.js';
+import { parseArgs } from '../../utils/args.js';
+import { VFSError } from '../../kernel/vfs/index.js';
+const spec = {
+    list: { type: 'boolean', short: 'l' },
+    overwrite: { type: 'boolean', short: 'o' },
+    'never-overwrite': { type: 'boolean', short: 'n' },
+    quiet: { type: 'boolean', short: 'q' },
+    junk: { type: 'boolean', short: 'j' },
+    pipe: { type: 'boolean', short: 'p' },
+    dir: { type: 'string', short: 'd' },
+    help: { type: 'boolean' },
+};
+const command = async (ctx) => {
+    const { flags, positional, unknown } = parseArgs(ctx.args, spec);
+    if (flags.help) {
+        ctx.stdout.write('Usage: unzip [-lonqjp] [-d dir] archive.zip\n');
+        ctx.stdout.write('  -l       list contents\n');
+        ctx.stdout.write('  -o       overwrite existing files without prompting\n');
+        ctx.stdout.write('  -n       never overwrite existing files\n');
+        ctx.stdout.write('  -q       quiet\n');
+        ctx.stdout.write('  -j       junk paths, extract every entry into one directory\n');
+        ctx.stdout.write('  -p       extract to stdout\n');
+        ctx.stdout.write('  -d dir   extract to directory\n');
+        return 0;
+    }
+    if (unknown.length > 0) {
+        ctx.stderr.write(`unzip: invalid option: ${unknown[0]}\n`);
+        return 1;
+    }
+    const archiveFile = positional[0];
+    if (!archiveFile) {
+        ctx.stderr.write('unzip: missing archive operand\n');
+        return 1;
+    }
+    const listOnly = flags.list === true;
+    const toStdout = flags.pipe === true;
+    const quiet = flags.quiet === true || toStdout;
+    const junkPaths = flags.junk === true;
+    const neverOverwrite = flags['never-overwrite'] === true;
+    const destDir = typeof flags.dir === 'string' ? flags.dir : '';
+    const archivePath = resolve(ctx.cwd, archiveFile);
+    const targetDir = destDir ? resolve(ctx.cwd, destDir) : ctx.cwd;
+    try {
+        const data = ctx.vfs.readFile(archivePath);
+        const entries = parseZip(data);
+        if (listOnly) {
+            ctx.stdout.write('  Length      Name\n');
+            ctx.stdout.write('---------  ----\n');
+            let totalSize = 0;
+            for (const entry of entries) {
+                const size = entry.data.length;
+                totalSize += size;
+                const path = entry.isDirectory ? entry.path + '/' : entry.path;
+                ctx.stdout.write(`${String(size).padStart(9)}  ${path}\n`);
+            }
+            ctx.stdout.write('---------  ----\n');
+            ctx.stdout.write(`${String(totalSize).padStart(9)}  ${entries.length} file(s)\n`);
+            return 0;
+        }
+        if (destDir) {
+            try {
+                ctx.vfs.mkdir(targetDir, { recursive: true });
+            }
+            catch { /* exists */ }
+        }
+        for (const entry of entries) {
+            const name = junkPaths ? entry.path.slice(entry.path.lastIndexOf('/') + 1) : entry.path;
+            if (entry.isDirectory) {
+                if (junkPaths)
+                    continue;
+                const entryPath = resolve(targetDir, name);
+                try {
+                    ctx.vfs.mkdir(entryPath, { recursive: true });
+                }
+                catch { /* exists */ }
+                if (!quiet)
+                    ctx.stdout.write(`  extracting: ${entry.path}/\n`);
+                continue;
+            }
+            if (toStdout) {
+                writeBytes(ctx.stdout, entry.data);
+                continue;
+            }
+            const entryPath = resolve(targetDir, name);
+            if (neverOverwrite && ctx.vfs.exists(entryPath))
+                continue;
+            const parent = dirname(entryPath);
+            try {
+                ctx.vfs.mkdir(parent, { recursive: true });
+            }
+            catch { /* exists */ }
+            ctx.vfs.writeFile(entryPath, entry.data);
+            if (!quiet)
+                ctx.stdout.write(`  extracting: ${entry.path}\n`);
+        }
+    }
+    catch (e) {
+        if (e instanceof VFSError) {
+            ctx.stderr.write(`unzip: ${e.message}\n`);
+            return 1;
+        }
+        throw e;
+    }
+    return 0;
+};
+function writeBytes(stdout, bytes) {
+    if (stdout.writeBytes)
+        stdout.writeBytes(bytes);
+    else
+        stdout.write(new TextDecoder().decode(bytes));
+}
+export default command;

package/dist/substrate/lifo/commands/archive/zip.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from '../types.js';
+declare const command: Command;
+export default command;
+//# sourceMappingURL=zip.d.ts.map

package/dist/substrate/lifo/commands/archive/zip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zip.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/commands/archive/zip.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAc3C,QAAA,MAAM,OAAO,EAAE,OAqDd,CAAC;AAEF,eAAe,OAAO,CAAC"}

package/dist/substrate/lifo/commands/archive/zip.js

@@ -0,0 +1,58 @@
+import { resolve } from '../../utils/path.js';
+import { createZip, collectFiles } from '../../utils/archive.js';
+import { parseArgs } from '../../utils/args.js';
+import { VFSError } from '../../kernel/vfs/index.js';
+const spec = {
+    recursive: { type: 'boolean', short: 'r' },
+    quiet: { type: 'boolean', short: 'q' },
+    junk: { type: 'boolean', short: 'j' },
+    help: { type: 'boolean' },
+};
+const command = async (ctx) => {
+    const { flags, positional, unknown } = parseArgs(ctx.args, spec);
+    if (flags.help || ctx.args.length === 0) {
+        ctx.stdout.write('Usage: zip [-rqj] archive.zip file1 [file2 ...]\n');
+        ctx.stdout.write('  -r   recurse into directories\n');
+        ctx.stdout.write('  -q   quiet\n');
+        ctx.stdout.write('  -j   junk paths, store each entry by basename\n');
+        return ctx.args.length === 0 ? 1 : 0;
+    }
+    // Compression levels are accepted and ignored: entries are stored, not
+    // deflated, so there is no level to honour.
+    const rejected = unknown.filter((o) => !/^-[0-9]$/.test(o));
+    if (rejected.length > 0) {
+        ctx.stderr.write(`zip: invalid option -- '${rejected[0].replace(/^-+/, '')}'\n`);
+        return 1;
+    }
+    const archiveFile = positional[0];
+    const files = positional.slice(1);
+    if (!archiveFile || files.length === 0) {
+        ctx.stderr.write('zip: no files to archive\n');
+        return 1;
+    }
+    const archivePath = resolve(ctx.cwd, archiveFile);
+    try {
+        const tarEntries = collectFiles(ctx.vfs, ctx.cwd, files);
+        const zipEntries = tarEntries.map((e) => ({
+            path: flags.junk ? e.path.slice(e.path.lastIndexOf('/') + 1) : e.path,
+            data: e.data,
+            isDirectory: e.type === 'directory',
+        }));
+        const data = createZip(zipEntries);
+        ctx.vfs.writeFile(archivePath, data);
+        if (!flags.quiet) {
+            for (const entry of zipEntries) {
+                ctx.stdout.write(`  adding: ${entry.path}${entry.isDirectory ? '/' : ''}\n`);
+            }
+        }
+    }
+    catch (e) {
+        if (e instanceof VFSError) {
+            ctx.stderr.write(`zip: ${e.message}\n`);
+            return 1;
+        }
+        throw e;
+    }
+    return 0;
+};
+export default command;

package/dist/substrate/lifo/commands/fs/basename.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from '../types.js';
+declare const command: Command;
+export default command;
+//# sourceMappingURL=basename.d.ts.map

package/dist/substrate/lifo/commands/fs/basename.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"basename.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/commands/fs/basename.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAG3C,QAAA,MAAM,OAAO,EAAE,OAUd,CAAC;AAEF,eAAe,OAAO,CAAC"}

package/dist/substrate/lifo/commands/fs/basename.js

@@ -0,0 +1,12 @@
+import { basename as pathBasename } from '../../utils/path.js';
+const command = async (ctx) => {
+    if (ctx.args.length === 0) {
+        ctx.stderr.write('basename: missing operand\n');
+        return 1;
+    }
+    const name = ctx.args[0];
+    const suffix = ctx.args[1];
+    ctx.stdout.write(pathBasename(name, suffix) + '\n');
+    return 0;
+};
+export default command;

package/dist/substrate/lifo/commands/fs/cat.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from '../types.js';
+declare const command: Command;
+export default command;
+//# sourceMappingURL=cat.d.ts.map

package/dist/substrate/lifo/commands/fs/cat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cat.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/commands/fs/cat.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAK3C,QAAA,MAAM,OAAO,EAAE,OA8Cd,CAAC;AAEF,eAAe,OAAO,CAAC"}

package/dist/substrate/lifo/commands/fs/cat.js

@@ -0,0 +1,52 @@
+import { resolve } from '../../utils/path.js';
+import { VFSError } from '../../kernel/vfs/index.js';
+import { SinkWriter, streamRange } from '../../../../_shared/byte-stream.js';
+const command = async (ctx) => {
+    if (ctx.args.length === 0) {
+        // Read from stdin if available (enables piping: echo hi | cat)
+        if (ctx.stdin) {
+            const content = await ctx.stdin.readAll();
+            ctx.stdout.write(content);
+            return 0;
+        }
+        ctx.stderr.write('cat: missing operand\n');
+        return 1;
+    }
+    let exitCode = 0;
+    // One writer across all operands: cat concatenates byte streams, so a
+    // multi-byte character split across an operand boundary stays one character.
+    const writer = new SinkWriter(ctx.stdout);
+    for (const arg of ctx.args) {
+        const path = resolve(ctx.cwd, arg);
+        try {
+            const stat = ctx.vfs.stat(path);
+            if (stat.type === 'directory')
+                throw new VFSError('EISDIR', `'${arg}': is a directory`);
+            if (stat.size > 0) {
+                // A regular file's size is its exact extent — copy precisely that, in
+                // bounded steps, so a large file never becomes a large buffer.
+                streamRange((offset, length) => ctx.vfs.readRange(path, offset, length), writer, {
+                    length: stat.size,
+                    signal: ctx.signal,
+                });
+            }
+            else {
+                // Empty files, /dev/null and synthesised /proc entries. Character
+                // devices with no end reject this unbounded read by design.
+                writer.write(ctx.vfs.readFile(path));
+            }
+        }
+        catch (e) {
+            if (e instanceof VFSError) {
+                ctx.stderr.write(`cat: ${arg}: ${e.message}\n`);
+                exitCode = 1;
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    writer.end();
+    return exitCode;
+};
+export default command;

package/dist/substrate/lifo/commands/fs/chmod.d.ts

@@ -0,0 +1,25 @@
+import type { Command } from '../types.js';
+interface SymbolicClause {
+    who: string;
+    op: '+' | '-' | '=';
+    perms: string;
+}
+export type ModeSpec = {
+    kind: 'absolute';
+    mode: number;
+} | {
+    kind: 'symbolic';
+    clauses: SymbolicClause[];
+};
+/** Parse an octal (755, 0644) or symbolic (+x, u+x, go-w, a=rx, a+rX) mode spec. */
+export declare function parseModeSpec(spec: string): ModeSpec | null;
+/**
+ * Apply a parsed mode spec to the current permission bits. `isDir`
+ * feeds the conditional-execute perm: 'X' grants x only to directories
+ * and files that already have some exec bit (chmod(1) semantics —
+ * `chmod -R a+rX` is a staple of npm postinstall scripts).
+ */
+export declare function applyModeSpec(spec: ModeSpec, currentMode: number, isDir?: boolean): number;
+declare const command: Command;
+export default command;
+//# sourceMappingURL=chmod.d.ts.map

package/dist/substrate/lifo/commands/fs/chmod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chmod.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/commands/fs/chmod.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAI3C,UAAU,cAAc;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,EAAE,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,MAAM,QAAQ,GAChB;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAClC;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,OAAO,EAAE,cAAc,EAAE,CAAA;CAAE,CAAC;AAEpD,oFAAoF;AACpF,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAW3D;AAKD;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK,UAAQ,GAAG,MAAM,CAmBxF;AAED,QAAA,MAAM,OAAO,EAAE,OAiDd,CAAC;AAEF,eAAe,OAAO,CAAC"}