@zenfs/core 1.8.4 → 1.8.6

package/dist/backends/overlay.js

@@ -103,7 +103,9 @@ export class OverlayFS extends FileSystem {
         this.writable.syncSync(path, data, stats);
     }
     async read(path, buffer, offset, end) {
-        return (await this.writable.exists(path)) ? await this.writable.read(path, buffer, offset, end) : await this.readable.read(path, buffer, offset, end);
+        return (await this.writable.exists(path))
+            ? await this.writable.read(path, buffer, offset, end)
+            : await this.readable.read(path, buffer, offset, end);
     }
     readSync(path, buffer, offset, end) {
         return this.writable.existsSync(path) ? this.writable.readSync(path, buffer, offset, end) : this.readable.readSync(path, buffer, offset, end);
@@ -403,7 +405,7 @@ export class OverlayFS extends FileSystem {
     }
     checkInitialized() {
         if (!this._isInitialized) {
-            throw new ErrnoError(Errno.EPERM, 'OverlayFS is not initialized. Please initialize OverlayFS using its initialize() method before using it.');
+            throw new ErrnoError(Errno.EPERM, 'Overlay is not initialized');
         }
         if (!this._deleteLogError) {
             return;

package/dist/backends/port/fs.js

@@ -4,6 +4,7 @@ import { Errno, ErrnoError } from '../../error.js';
 import { FileSystem } from '../../filesystem.js';
 import { Async } from '../../mixins/async.js';
 import { Stats } from '../../stats.js';
+import { decodeUTF8 } from '../../utils.js';
 import { InMemory } from '../memory.js';
 import * as RPC from './rpc.js';
 /**
@@ -33,7 +34,10 @@ export class PortFS extends Async(FileSystem) {
         };
     }
     rpc(method, ...args) {
-        return RPC.request({ method, args }, { ...this.options, fs: this });
+        return RPC.request({ method, args }, {
+            ...this.options,
+            fs: this,
+        });
     }
     async ready() {
         await this.rpc('ready');

package/dist/backends/port/rpc.d.ts

@@ -56,7 +56,7 @@ export interface FileData {
     flag: string;
     stats: StatsLike<number>;
 }
-export { FileData as File };
+export type { FileData as File };
 export declare function isMessage(arg: unknown): arg is Message;
 type _Executor = Parameters<ConstructorParameters<typeof Promise<any>>[0]>;
 export interface Executor {

package/dist/backends/store/file_index.d.ts

@@ -23,8 +23,10 @@ export declare class Index extends Map<string, Readonly<Inode>> {
      * Converts the index to a string
      */
     toString(): string;
+    directoryEntries(path: string): Record<string, number>;
     /**
-     * Gets a list of entries for each directory in the index. Memoized.
+     * Gets a list of entries for each directory in the index.
+     * Use
      */
     directories(): Map<string, Record<string, number>>;
     /**

package/dist/backends/store/file_index.js

@@ -25,12 +25,25 @@ export class Index extends Map {
     toString() {
         return JSON.stringify(this.toJSON());
     }
+    directoryEntries(path) {
+        const node = this.get(path);
+        if (!node)
+            throw ErrnoError.With('ENOENT', path);
+        if ((node.mode & S_IFMT) != S_IFDIR)
+            throw ErrnoError.With('ENOTDIR', path);
+        const entries = {};
+        for (const entry of this.keys()) {
+            if (dirname(entry) == path && entry != path) {
+                entries[basename(entry)] = this.get(entry).ino;
+            }
+        }
+        return entries;
+    }
     /**
-     * Gets a list of entries for each directory in the index. Memoized.
+     * Gets a list of entries for each directory in the index.
+     * Use
      */
     directories() {
-        if (this._directories)
-            return this._directories;
         const dirs = new Map();
         for (const [path, node] of this) {
             if ((node.mode & S_IFMT) != S_IFDIR)
@@ -42,7 +55,6 @@ export class Index extends Map {
             }
             dirs.set(path, entries);
         }
-        this._directories = dirs;
         return dirs;
     }
     /**

package/dist/backends/store/fs.js

@@ -247,7 +247,9 @@ export class StoreFS extends FileSystem {
             const sameParent = _new.dir == _old.dir;
             // Prevent us from re-grabbing the same directory listing, which still contains `old_path.base.`
             const newDirNode = sameParent ? oldDirNode : await this.findInode(tx, _new.dir, 'rename');
-            const newDirList = sameParent ? oldDirList : decodeDirListing((_b = (await tx.get(newDirNode.data))) !== null && _b !== void 0 ? _b : _throw(ErrnoError.With('ENOENT', _new.dir, 'rename')));
+            const newDirList = sameParent
+                ? oldDirList
+                : decodeDirListing((_b = (await tx.get(newDirNode.data))) !== null && _b !== void 0 ? _b : _throw(ErrnoError.With('ENOENT', _new.dir, 'rename')));
             if (newDirList[_new.base]) {
                 // If it's a file, delete it, if it's a directory, throw a permissions error.
                 const existing = new Inode((_c = (await tx.get(newDirList[_new.base]))) !== null && _c !== void 0 ? _c : _throw(ErrnoError.With('ENOENT', newPath, 'rename')));
@@ -298,7 +300,9 @@ export class StoreFS extends FileSystem {
             const sameParent = _new.dir === _old.dir;
             // Prevent us from re-grabbing the same directory listing, which still contains `old_path.base.`
             const newDirNode = sameParent ? oldDirNode : this.findInodeSync(tx, _new.dir, 'rename');
-            const newDirList = sameParent ? oldDirList : decodeDirListing((_b = tx.getSync(newDirNode.data)) !== null && _b !== void 0 ? _b : _throw(ErrnoError.With('ENOENT', _new.dir, 'rename')));
+            const newDirList = sameParent
+                ? oldDirList
+                : decodeDirListing((_b = tx.getSync(newDirNode.data)) !== null && _b !== void 0 ? _b : _throw(ErrnoError.With('ENOENT', _new.dir, 'rename')));
             if (newDirList[_new.base]) {
                 // If it's a file, delete it, if it's a directory, throw a permissions error.
                 const existing = new Inode((_c = tx.getSync(newDirList[_new.base])) !== null && _c !== void 0 ? _c : _throw(ErrnoError.With('ENOENT', newPath, 'rename')));
@@ -692,7 +696,9 @@ export class StoreFS extends FileSystem {
             return rootIno;
         }
         const { dir: parent, base: filename } = parse(path);
-        const inode = parent == '/' ? new Inode((_a = (await tx.get(rootIno))) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENOENT', parent, syscall))) : await this.findInode(tx, parent, syscall, visited);
+        const inode = parent == '/'
+            ? new Inode((_a = (await tx.get(rootIno))) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENOENT', parent, syscall)))
+            : await this.findInode(tx, parent, syscall, visited);
         const dirList = decodeDirListing((_b = (await tx.get(inode.data))) !== null && _b !== void 0 ? _b : _throw(ErrnoError.With('ENODATA', parent, syscall)));
         if (!(filename in dirList)) {
             throw ErrnoError.With('ENOENT', resolve(parent, filename), syscall);
@@ -716,7 +722,9 @@ export class StoreFS extends FileSystem {
             return rootIno;
         }
         const { dir: parent, base: filename } = parse(path);
-        const inode = parent == '/' ? new Inode((_a = tx.getSync(rootIno)) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENOENT', parent, syscall))) : this.findInodeSync(tx, parent, syscall, visited);
+        const inode = parent == '/'
+            ? new Inode((_a = tx.getSync(rootIno)) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENOENT', parent, syscall)))
+            : this.findInodeSync(tx, parent, syscall, visited);
         const dir = decodeDirListing((_b = tx.getSync(inode.data)) !== null && _b !== void 0 ? _b : _throw(ErrnoError.With('ENODATA', parent, syscall)));
         if (!(filename in dir)) {
             throw ErrnoError.With('ENOENT', resolve(parent, filename), syscall);

package/dist/backends/store/inode.js

@@ -109,7 +109,7 @@ let Inode = (() => {
             this.data = __runInitializers(this, _data_initializers, randomInt(0, size_max));
             /** For future use */
             this.__data_old = (__runInitializers(this, _data_extraInitializers), __runInitializers(this, ___data_old_initializers, 0));
-            this.size = (__runInitializers(this, ___data_old_extraInitializers), __runInitializers(this, _size_initializers, 4096));
+            this.size = (__runInitializers(this, ___data_old_extraInitializers), __runInitializers(this, _size_initializers, 0));
             this.mode = (__runInitializers(this, _size_extraInitializers), __runInitializers(this, _mode_initializers, 0));
             this.nlink = (__runInitializers(this, _mode_extraInitializers), __runInitializers(this, _nlink_initializers, 1));
             this.uid = (__runInitializers(this, _nlink_extraInitializers), __runInitializers(this, _uid_initializers, 0));

package/dist/mixins/async.js

@@ -243,7 +243,19 @@ export function Async(FS) {
          * Patch all async methods to also call their synchronous counterparts unless called from the queue
          */
         _patchAsync() {
-            const asyncFSMethodKeys = ['rename', 'stat', 'createFile', 'openFile', 'unlink', 'rmdir', 'mkdir', 'readdir', 'link', 'sync', 'exists'];
+            const asyncFSMethodKeys = [
+                'rename',
+                'stat',
+                'createFile',
+                'openFile',
+                'unlink',
+                'rmdir',
+                'mkdir',
+                'readdir',
+                'link',
+                'sync',
+                'exists',
+            ];
             for (const key of asyncFSMethodKeys) {
                 if (typeof this[key] !== 'function')
                     continue;

package/dist/stats.js

@@ -231,7 +231,11 @@ export class BigIntStats extends StatsCommon {
  * @internal
  */
 export function isStatsEqual(left, right) {
-    return left.size == right.size && +left.atime == +right.atime && +left.mtime == +right.mtime && +left.ctime == +right.ctime && left.mode == right.mode;
+    return (left.size == right.size &&
+        +left.atime == +right.atime &&
+        +left.mtime == +right.mtime &&
+        +left.ctime == +right.ctime &&
+        left.mode == right.mode);
 }
 /** @internal */
 export const ZenFsType = 0x7a656e6673; // 'z' 'e' 'n' 'f' 's'

package/dist/utils.js

@@ -56,7 +56,7 @@ export { /** @deprecated @hidden */ decodeUTF8 as decode };
  * @hidden
  */
 export function decodeDirListing(data) {
-    return JSON.parse(decodeUTF8(data), (k, v) => (k == '' ? v : typeof v == 'string' ? BigInt(v).toString(16).slice(0, Math.min(v.length, 8)) : v));
+    return JSON.parse(decodeUTF8(data), (k, v) => k == '' ? v : typeof v == 'string' ? BigInt(v).toString(16).slice(0, Math.min(v.length, 8)) : v);
 }
 /**
  * Encodes a directory listing

package/dist/vfs/promises.js

@@ -564,7 +564,11 @@ export async function writeFile(path, data, _options) {
     try {
         const options = normalizeOptions(_options, 'utf8', 'w+', 0o644);
         const handle = __addDisposableResource(env_3, path instanceof FileHandle ? path : await open.call(this, path.toString(), options.flag, options.mode), true);
-        const _data = typeof data == 'string' ? data : data instanceof DataView ? new Uint8Array(data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength)) : data;
+        const _data = typeof data == 'string'
+            ? data
+            : data instanceof DataView
+                ? new Uint8Array(data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength))
+                : data;
         if (typeof _data != 'string' && !(_data instanceof Uint8Array)) {
             throw new ErrnoError(Errno.EINVAL, 'The "data" argument must be of type string or an instance of Buffer, TypedArray, or DataView. Received ' + typeof data, handle.file.path, 'writeFile');
         }
@@ -1110,7 +1114,10 @@ export async function cp(source, destination, opts) {
             if (!(opts === null || opts === void 0 ? void 0 : opts.recursive)) {
                 throw new ErrnoError(Errno.EISDIR, source + ' is a directory (not copied)', source, 'cp');
             }
-            const [entries] = await Promise.all([readdir.call(this, source, { withFileTypes: true }), mkdir.call(this, destination, { recursive: true })] // Ensure the destination directory exists
+            const [entries] = await Promise.all([
+                readdir.call(this, source, { withFileTypes: true }),
+                mkdir.call(this, destination, { recursive: true }),
+            ] // Ensure the destination directory exists
             );
             const _cp = async (dirent) => {
                 if (opts.filter && !opts.filter(join(source, dirent.name), join(destination, dirent.name))) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "1.8.4",
+	"version": "1.8.6",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",
@@ -15,7 +15,8 @@
 	],
 	"bin": {
 		"make-index": "scripts/make-index.js",
-		"zenfs-test": "scripts/test.js"
+		"zenfs-test": "scripts/test.js",
+		"zci": "scripts/ci-cli.js"
 	},
 	"files": [
 		"dist",
@@ -73,14 +74,15 @@
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.8.0",
+		"@octokit/action": "^7.0.0",
 		"@types/eslint__js": "^8.42.3",
+		"c8": "^10.1.2",
 		"eslint": "^9.15.0",
 		"globals": "^15.9.0",
 		"prettier": "^3.2.5",
 		"tsx": "^4.19.1",
 		"typedoc": "^0.27.1",
 		"typescript": "^5.7.2",
-		"typescript-eslint": "^8.16.0",
-		"c8": "^10.1.2"
+		"typescript-eslint": "^8.16.0"
 	}
 }

package/scripts/ci-cli.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+import { parseArgs } from 'node:util';
+import * as ci from './ci.js';
+
+const {
+	values: options,
+	positionals: [subcommand, ...args],
+} = parseArgs({
+	options: {
+		help: { short: 'h', type: 'boolean', default: false },
+	},
+	allowPositionals: true,
+});
+
+if (options.help || !subcommand) {
+	console.log(`Usage:
+zci [-h | --help]     Show this help message
+zci init              Create checks in a queued state
+zci cleanup           Mark all remaining checks are completed with a neutral status
+zci run <name> <cmd>  Run a command and use its exit code as the completion status
+zci list              List checks`);
+	process.exit();
+}
+
+switch (subcommand) {
+	case 'init':
+		for (const [id, name] of Object.entries(ci.checkNames)) {
+			await ci.createCheck(id, name);
+		}
+		break;
+	case 'list': {
+		const max = Math.max(...Object.keys(ci.checkNames).map(id => id.length)) + 1;
+		for (const [id, name] of Object.entries(ci.checkNames)) {
+			console.log(id.padEnd(max), name);
+		}
+		break;
+	}
+	case 'run': {
+		const [name, ...command] = args;
+
+		await ci.startCheck(name);
+
+		const { status } = spawnSync(command.join(' '), { shell: true, stdio: 'inherit' });
+
+		await ci.completeCheck(name, status ? 'failure' : 'success');
+
+		process.exit(status);
+	}
+	case 'cleanup': {
+		for (const id of Object.keys(ci.checkNames)) {
+			await ci.completeCheck(id, 'neutral');
+		}
+		break;
+	}
+	default:
+		console.error('Unknown subcommand:', subcommand);
+		process.exit(1);
+}

package/scripts/test.js

@@ -1,25 +1,33 @@
 #!/usr/bin/env node
 
 import { execSync } from 'node:child_process';
-import { existsSync, mkdirSync, rmSync, globSync } from 'node:fs';
-import { join } from 'node:path';
+import { existsSync, globSync, mkdirSync, rmSync } from 'node:fs';
+import { join, parse } from 'node:path';
 import { parseArgs } from 'node:util';
 
 const { values: options, positionals } = parseArgs({
 	options: {
+		// Output
 		help: { short: 'h', type: 'boolean', default: false },
 		verbose: { short: 'w', type: 'boolean', default: false },
 		quiet: { short: 'q', type: 'boolean', default: false },
+		'file-names': { short: 'N', type: 'boolean', default: false },
+		ci: { short: 'C', type: 'boolean', default: false },
+
+		// Test behavior
 		test: { short: 't', type: 'string' },
 		force: { short: 'f', type: 'boolean', default: false },
 		auto: { short: 'a', type: 'boolean', default: false },
 		build: { short: 'b', type: 'boolean', default: false },
 		common: { short: 'c', type: 'boolean', default: false },
+		inspect: { short: 'I', type: 'boolean', default: false },
+		'exit-on-fail': { short: 'e', type: 'boolean' },
+
+		// Coverage
 		coverage: { type: 'string', default: 'tests/.coverage' },
 		preserve: { short: 'p', type: 'boolean' },
-		'exit-on-fail': { short: 'e', type: 'boolean' },
-		report: { type: 'boolean' },
-		clean: { type: 'boolean' },
+		report: { type: 'boolean', default: false },
+		clean: { type: 'boolean', default: false },
 	},
 	allowPositionals: true,
 });
@@ -29,21 +37,27 @@ if (options.help) {
 
 Paths: The setup files to run tests on
 
-Options:
+Behavior:
     -a, --auto          Automatically detect setup files
     -b, --build         Run the npm build script prior to running tests
     -c, --common        Also run tests not specific to any backend
     -e, --exit-on-fail  If any tests suites fail, exit immediately
+    -t, --test <glob>   Which FS test suite(s) to run
+    -f, --force         Whether to use --test-force-exit
+    -I, --inspect       Use the inspector for debugging
+
+Output:
     -h, --help          Outputs this help message
     -w, --verbose       Output verbose messages
     -q, --quiet         Don't output normal messages
-    -t, --test <glob>   Which FS test suite(s) to run
-    -f, --force         Whether to use --test-force-exit
+    -N, --file-names    Use full file paths for tests from setup files instead of the base name
+    -C, --ci            Continuous integration (CI) mode. This interacts with the Github
+                        Checks API for better test status. Requires @octokit/action
 
 Coverage:
     --coverage <dir>    Override the default coverage data directory
-    -p,--preserve       Do not delete or report coverage data
-	--report            ONLY report coverage
+    -p, --preserve      Do not delete or report coverage data
+    --report            ONLY report coverage
     --clean             ONLY clean up coverage directory`);
 	process.exit();
 }
@@ -66,6 +80,9 @@ if (options.report) {
 	process.exit();
 }
 
+let ci;
+if (options.ci) ci = await import('./ci.js');
+
 options.verbose && options.force && console.debug('Forcing tests to exit (--test-force-exit)');
 
 if (options.build) {
@@ -104,9 +121,11 @@ function color(text, code) {
 	return `\x1b[${code}m${text}\x1b[0m`;
 }
 
-function status(name) {
+async function status(name) {
 	const start = performance.now();
 
+	if (options.ci) await ci.startCheck(name);
+
 	const time = () => {
 		let delta = Math.round(performance.now() - start),
 			unit = 'ms';
@@ -120,11 +139,13 @@ function status(name) {
 	};
 
 	return {
-		pass() {
+		async pass() {
 			if (!options.quiet) console.log(`${color('passed', 32)}: ${name} ${time()}`);
+			if (options.ci) await ci.completeCheck(name, 'success');
 		},
-		fail() {
+		async fail() {
 			console.error(`${color('failed', '1;31')}: ${name} ${time()}`);
+			if (options.ci) await ci.completeCheck(name, 'failure');
 			process.exitCode = 1;
 			if (options['exit-on-fail']) process.exit();
 		},
@@ -136,14 +157,14 @@ mkdirSync(options.coverage, { recursive: true });
 
 if (options.common) {
 	!options.quiet && console.log('Running common tests...');
-	const { pass, fail } = status('Common tests');
+	const { pass, fail } = await status('Common tests');
 	try {
-		execSync("tsx --test --experimental-test-coverage 'tests/*.test.ts' 'tests/**/!(fs)/*.test.ts'", {
+		execSync(`tsx ${options.inspect ? 'inspect' : ''} --test --experimental-test-coverage 'tests/*.test.ts' 'tests/**/!(fs)/*.test.ts'`, {
 			stdio: ['ignore', options.verbose ? 'inherit' : 'ignore', 'inherit'],
 		});
-		pass();
+		await pass();
 	} catch {
-		fail();
+		await fail();
 	}
 }
 
@@ -155,18 +176,31 @@ for (const setupFile of positionals) {
 		continue;
 	}
 
-	!options.quiet && console.log('Running tests:', setupFile);
 	process.env.SETUP = setupFile;
 
-	const { pass, fail } = status(setupFile);
+	const name = options['file-names'] && !options.ci ? setupFile : parse(setupFile).name;
+
+	!options.quiet && console.log('Running tests:', name);
+
+	const { pass, fail } = await status(name);
 
 	try {
-		execSync(['tsx --test --experimental-test-coverage', options.force ? '--test-force-exit' : '', testsGlob, process.env.CMD].join(' '), {
-			stdio: ['ignore', options.verbose ? 'inherit' : 'ignore', 'inherit'],
-		});
-		pass();
+		execSync(
+			[
+				'tsx',
+				options.inspect ? 'inspect' : '',
+				'--test --experimental-test-coverage',
+				options.force ? '--test-force-exit' : '',
+				testsGlob,
+				process.env.CMD,
+			].join(' '),
+			{
+				stdio: ['ignore', options.verbose ? 'inherit' : 'ignore', 'inherit'],
+			}
+		);
+		await pass();
 	} catch {
-		fail();
+		await fail();
 	}
 }
 

package/tests/fetch/run.sh

@@ -11,6 +11,6 @@ until nc -z localhost 26514; do
   sleep 0.5
 done
 
-npx zenfs-test $SCRIPT_DIR/setup.ts --preserve --force $@
+npx zenfs-test $SCRIPT_DIR/cow+fetch.ts --preserve --force "$@"
 
 kill $PID