instrumentality 0.0.3 → 0.0.4

package/dist/road.js

@@ -5,24 +5,22 @@ import * as fp from "node:fs/promises";
 import * as ph from "node:path";
 import * as os from "node:os";
 import * as cr from "node:crypto";
-import * as sp from "node:stream/promises";
 import { on } from "node:events";
 import * as bs from "./base.js";
-/**
- * Subclass of {@link bs.InsErr} that represents an error thrown from this specific module of the library
- */
+/** Subclass of {@link bs.InsErr} that represents an error thrown from this specific module of the library */
 export class RdErr extends bs.InsErr {
     name = "Instrumentality-Road-Error";
 }
+export { RdErr as RoadError };
 /**
- * Returns the constructor function corresponding to the file mode.
+ * Returns the constructor function corresponding to the file mode (statmode).
  *
- * @param statmode The file mode to check.
- * @returns The constructor function corresponding to the file mode.
+ * @param statmode_ The file mode to check.
+ * @returns The constructor function corresponding to the road type (e.g., {@link File}, {@link Folder}, etc.).
  * @throws If the file mode is unknown, throws a {@link RdErr}.
  */
-export function resolveMode(statmode) {
-    switch (statmode & fsc.S_IFMT) {
+export function resolveMode(statmode_) {
+    switch (statmode_ & fsc.S_IFMT) {
         case fsc.S_IFREG: return File;
         case fsc.S_IFDIR: return Folder;
         case fsc.S_IFBLK: return BlockDevice;
@@ -30,41 +28,40 @@ export function resolveMode(statmode) {
         case fsc.S_IFLNK: return SymbolicLink;
         case fsc.S_IFIFO: return Fifo;
         case fsc.S_IFSOCK: return Socket;
-        default: throw new RdErr(`Unknown mode type ${statmode} (statmode is most likely corrupted)`);
+        default: throw new RdErr(`Unknown mode type ${statmode_} (statmode is most likely corrupted)`);
     }
 }
 /**
- * Creates a new instance of the appropriate subclass of {@link Road} based on the file mode of the specified path.
+ * Creates the appropriate subclass of {@link Road} based on the file mode of the specified path.
  *
- * @param lookFor The path to check.
- * @returns A new instance of the appropriate subclass of {@link Road}.
- * @throws If the path does not exist, throws a fs {@link Error}.
+ * @param path_ The path to follow.
+ * @returns A new instance of {@link Road}.
+ * @throws If {@link fp.lstat}/{@link fs.lstatSync} fails to retrieved the status of {@link path_}.
  */
-export function factorySync(lookFor) {
-    fs.accessSync(lookFor, fsc.F_OK);
-    return new (resolveMode(fs.lstatSync(lookFor).mode))(lookFor, false);
+export async function factory(path_) {
+    return new (resolveMode((await fp.lstat(path_)).mode))(path_, false);
 }
-/** Async version of {@link factorySync}. */
-export async function factory(lookFor) {
-    await fp.access(lookFor, fsc.F_OK);
-    return new (resolveMode((await fp.lstat(lookFor)).mode))(lookFor, false);
+/** Sync version of {@link factory}. */
+export function factorySync(path_) {
+    return new (resolveMode(fs.lstatSync(path_).mode))(path_, false);
 }
 /**
- * A map that keeps track of locked roads to prevent concurrent modifications. The keys are the absolute paths of the roads, and the values are promises that resolve when the lock is released.
+ * A map that keeps track of locked roads to prevent concurrent modifications.
+ *
+ * @key The absolute path of the road that is currently locked.
+ * @value A promise that resolves when the lock on the road is released.
  *
- * @remarks Don't manually modify this map. Use the {@link Road.initChange} and {@link Road.initChangeSync} methods to acquire and release locks on roads.
- * For read-only purposes, you should use the {@link lockFor} function to await the optional lock on a road.
+ * @remarks The map is initialized lazily when the first lock is created to minimize import-time side effects.
+ * It's generally meant for read-only purposes. It's not advised to modify this map directly if there are built-in mechanisms that do the job for you as well.
  */
-let lockedRoads = null;
+export let lockedRoads = null;
 /**
- * Getter for the locked roads map.
+ * Road is an OOP, pointer-like representation of an entry in the local file system. It wraps around the Node.js fs module and provides a more convenient access to it.
+ * It's meant to help the user mentally model an entry and help them reason about it, as well as provide a more convenient API and guardrails for common operations.
  *
- * @param roadOrPath - A {@link Road} instance or a string representing the absolute path of the road to check.
- * @returns The promise associated with the locked road, or `undefined` if the road is not currently locked.
+ * @remarks This is by no means a one-to-one mapping of the underlying file system (after initialization).
+ * It is more like a memory representation, similar to a pointer in low-level programming languages; other processes might mess with the underlying entry. There are methods to check for consistency, but they are not guaranteed to be foolproof.
  */
-export function lockFor(roadOrPath) {
-    return lockedRoads?.get(roadOrPath.toString());
-}
 export class Road {
     /** The absolute path to the file or directory that this Road instance represents.
      * @remarks Intentionally made protected to prevent external modification, as changing this value could lead to inconsistencies and unexpected behavior. */
@@ -73,138 +70,85 @@ export class Road {
      * Changing this value does not affect the actual file system permissions, but rather serves as a safeguard within the application to prevent accidental modifications. */
     mutable = true;
     // Quick accessors
-    /** Accessor for the absolute path to the file or directory that this Road instance represents. */
+    /** Copy of the absolute path. */
     get isAt() { return this.pointsTo; }
-    /** Accessor for the name of the file or directory that this Road instance represents. */
+    /** Name of the road without the path (including extensions). */
     get name() { return this.isAt.slice(this.isAt.lastIndexOf(ph.sep) + 1); }
-    /** Same as {@link isAt} but for compatibility with external libraries that try to convert the object to a string. */
+    /** The amount of path segments in the absolute path to the file or directory represented by this Road instance, minus one (i.e., the depth of the path in the file system hierarchy). */
+    get depth() { return this.isAt.split(ph.sep).length - 1; }
+    /** Same as {@link isAt} but for compatibility with external APIs. */
     toString() { return this.isAt; }
-    /** Returns the OS file type of the file or directory.
-     * Return value (OS type) and the type of this instance are not guaranteed to be the same, as the file system may have changed since this instance was created. */
-    typeSync() { return (resolveMode(fs.lstatSync(this.isAt).mode)); }
-    /** Async version of {@link typeSync}. */
-    async type() { return (resolveMode((await fp.lstat(this.isAt)).mode)); }
     /**
-     * Constructs a new Road instance representing the file or directory at the specified path.
+     * Creates a new instance of the Road class.
      *
-     * @param lookFor The path to the file or directory that this Road instance will represent.
-     * @param typeCheck Whether to check if the type of the file or directory at the specified path matches the type of this instance.
-     * This can be skipped for performance reasons if the type is known to be correct, but it is recommended to keep it enabled for safety.
-     * @throws If the specified path does not exist, throws a fs.{@link Error}.
-     * @throws If the type of the file or directory at the specified path does not match the type of this instance, throws a {@link RdErr}. Useful for subclasses.
-     */
-    constructor(lookFor, typeCheck) {
-        this.pointsTo = ph.resolve(lookFor);
-        if (typeCheck && !(this instanceof this.typeSync())) // `this` directly refers to the subclass
-            throw new RdErr(`Type missmatch: Path '${this.isAt}' is not of constructed type ${this.constructor.name}.`);
-    }
-    /**
-     * Verifies that the file or directory represented by this Road instance exists, is of the same type as this instance, and (optionally) is writable.
+     * @param path_ Any path-like string that can be resolved to an absolute path. It will be resolved to an absolute path using {@link ph.resolve}.
+     * @param typeCheck_ If true, the constructor will check if the path corresponds to the expected type of road (e.g., file, folder, etc.) and throw an error if it doesn't. If false, no type checking will be performed.
      *
-     * @param expectMode The expected access mode for this Road other than visibility by this process.
-     * @returns Result of the verification.
+     * @throws If {@link typeCheck_} is true and the path does not correspond to the expected type of road, a {@link RdErr} will be thrown.
      */
-    async verify(expectMode, typeCheck) {
-        try {
-            await fp.access(this.isAt, fsc.F_OK | expectMode);
-            return typeCheck || this instanceof (await this.type());
-        }
-        catch {
-            return false;
-        }
-    }
-    /** Sync version of {@link verify}. */
-    verifySync(expectMode, typeCheck) {
-        try {
-            fs.accessSync(this.isAt, fsc.F_OK | expectMode);
-            return typeCheck || this instanceof this.typeSync();
-        }
-        catch {
-            return false;
-        }
+    constructor(path_, typeCheck_) {
+        this.pointsTo = ph.resolve(path_);
+        if (typeCheck_ && !this.checkSync())
+            throw new RdErr(`Type mismatch: '${this.isAt}'`);
     }
     /**
-     * Creates a disposable lock for the file or directory represented by this Road instance, preventing concurrent modifications.
+     * Aquires a lock for the path represented by this Road instance, preventing concurrent modifications from this and other Road instances pointing to the same path.
+     *
+     * @param cb_ A callback function that will be called when the lock is released. This is used internally to manage the lock state.
+     * @returns An object with a dispose method that releases the lock when called.
+     * @throws If the road is immutable, a {@link RdErr} will be thrown.
      *
-     * @returns An object with a `dispose` method that releases the lock when called. The lock is automatically released when the object is garbage collected.
-     * @remarks Please use this method with the `await using` statement to ensure that the lock is properly released after the operation is complete. This method is intended for internal use and shouldn't be called directly in most cases. (that's why it's protected)
+     * @remarks This method MUST be used with a `using` statement to ensure that the lock is released properly. Failing to do so may result in deadlocks or other concurrency issues.
+     * Non-deterministic release is unfortunately not possible due to the nature of JavaScript's garbage collection, thus the lock must be released deterministically by the user (to which the `using` statement is a convenient way to do so).
      */
-    async initChange() {
-        if (!await this.verify(fsc.R_OK | fsc.W_OK, true))
-            throw new RdErr(`Road to '${this.isAt}' (${this.constructor.name}) isn't the same as during construction, can't modify (OS type: ${fs.existsSync(this.isAt) ? this.typeSync().name : 'nonexistent'})`);
+    async lock(cb_ = () => { }) {
         if (!this.mutable)
-            throw new RdErr(`Attempting to modify road to '${this.isAt}' of type ${this.constructor.name} which's marked as immutable (unrelated to the actual OS file permissions)`);
-        if (!lockedRoads)
-            lockedRoads = new Map();
-        const lockedPath = this.isAt;
-        let releaseLock = () => { };
-        await lockFor(lockedPath);
-        lockedRoads.set(lockedPath, new Promise(res => releaseLock = res));
+            throw new RdErr(`Road to '${this.isAt}' is immutable.`);
+        lockedRoads ??= new Map();
+        const isAt = this.isAt;
+        await lockedRoads.get(isAt); // will skip if `undefined` (no lock)
+        lockedRoads.set(isAt, new Promise(res => cb_ = res));
         return {
             [Symbol.dispose]() {
-                releaseLock();
-                releaseLock = () => { throw new RdErr("Lock already released, can't dispose"); };
-                lockedRoads.delete(lockedPath);
+                cb_();
+                lockedRoads.delete(isAt);
             },
             async [Symbol.asyncDispose]() {
-                releaseLock();
-                releaseLock = () => { throw new RdErr("Lock already released, can't dispose"); };
-                lockedRoads.delete(lockedPath);
+                cb_();
+                lockedRoads.delete(isAt);
             }
         };
     }
     /**
-     * Sync version of {@link initChangeSync}.
-     *
-     * @remarks This sync version will throw if the road is already locked by another operation.
+     * Sync version of {@link lock}.
+     * @throws Also throws a {@link RdErr} if the road is currently locked by another operation as it cannot wait for the lock to be released in a synchronous context.
      */
-    initChangeSync() {
-        if (!this.verifySync(fsc.R_OK | fsc.W_OK, true))
-            throw new RdErr(`Road to '${this.isAt}' (${this.constructor.name}) isn't the same as during construction, can't modify (OS type: ${fs.existsSync(this.isAt) ? this.typeSync().name : 'nonexistent'})`);
+    lockSync(cb_ = () => { }) {
         if (!this.mutable)
-            throw new RdErr(`Attempting to modify road to '${this.isAt}' of type ${this.constructor.name} which's marked as immutable (unrelated to the actual OS file permissions)`);
-        if (!lockedRoads)
-            lockedRoads = new Map();
-        const lockedPath = this.isAt;
-        if (lockedRoads.has(lockedPath))
-            throw new RdErr(`Road to '${this.isAt}' is currently locked by another operation, can't modify synchronously`);
-        let releaseLock = () => { };
-        lockedRoads.set(lockedPath, new Promise(res => releaseLock = res));
+            throw new RdErr(`Road to '${this.isAt}' is immutable.`);
+        lockedRoads ??= new Map();
+        const isAt = this.isAt;
+        if (lockedRoads.has(isAt))
+            throw new RdErr(`Road to '${this.isAt}' is currently locked by another operation.`);
+        lockedRoads.set(isAt, new Promise(res => cb_ = res));
         return {
             [Symbol.dispose]() {
-                lockedRoads.delete(lockedPath);
-                releaseLock();
-                releaseLock = () => { throw new RdErr("Lock already released, can't dispose"); };
+                lockedRoads.delete(isAt);
+                cb_();
             },
             async [Symbol.asyncDispose]() {
-                lockedRoads.delete(lockedPath);
-                releaseLock();
-                releaseLock = () => { throw new RdErr("Lock already released, can't dispose"); };
+                lockedRoads.delete(isAt);
+                cb_();
             }
         };
     }
+    /** @returns An instance of {@link Folder} representing the parent directory of the current road. */
+    parent() { return new Folder(ph.dirname(this.isAt), false); }
     /**
-     * Checks if the file or directory represented by this Road is both visible and of the same type as expected.
-     */
-    async exists() { return this.verify(fsc.F_OK, true); }
-    existsSync() { return this.verifySync(fsc.F_OK, true); }
-    /**
-     * @returns The file system stats for the file or directory.
-     * @see {@link fs.lstat}
-     */
-    async stats() { return fp.lstat(this.isAt); }
-    /**
-     * @returns The file system stats for the file or directory.
-     * @see {@link fs.lstatSync}
-     */
-    statsSync() { return fs.lstatSync(this.isAt); }
-    /**
-     * @returns The amount of path segments in the absolute path to the file or directory represented by this Road instance, minus one (i.e., the depth of the file or directory in the file system hierarchy).
-     * @remarks As subclasses of {@link Road} require all paths to be absolute/normalized and valid, this method is guaranteed to return a non-negative integer.
+     * An async generator that yields the ancestors of the current road, starting from its parent and moving up the directory tree until it reaches the root.
+     *
+     * @yields Each ancestor folder as a {@link Folder} instance.
      */
-    depth() { return this.isAt.split(ph.sep).length - 1; }
-    /** @returns The parent folder of the file or directory represented by this Road instance. */
-    parent() { return new Folder(ph.dirname(this.isAt), false); }
     *ancestorsIt() {
         let current = this.parent();
         let parent = current.parent();
@@ -214,28 +158,50 @@ export class Road {
             parent = current.parent();
         }
     }
+    /** @returns An array of {@link Folder} instances representing the ancestors of the current road. */
     ancestors() { return [...this.ancestorsIt()]; }
-    async untilAccessible(mode = fsc.F_OK, abs, onEachAttempt) {
+    /**
+     * Watches the current entry for changes and resolves when the entry becomes accessible (i.e., exists and can be accessed).
+     *
+     * @param abs An {@link AbortSignal} that stops the watching process when aborted.
+     * @param expectMode The expected access mode for the entry, defaults to {@link fsc.F_OK} (existence check).
+     * @param cb_ An optional callback function that will be called with any errors encountered while checking for accessibility.
+     * @see {@link fp.access} on how the check for accessibility is performed.
+     * @see {@link fs.watch} for more information on how the watching process works.
+     * @see {@link on} for more information on how the event listener is set up.
+     */
+    async untilAccessible(abs, expectMode = fsc.F_OK, cb_) {
         const watcher = fs.watch(this.isAt);
         try {
-            if (await this.verify(mode, true))
-                return;
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            for await (let _ of on(watcher, 'change', { signal: abs }))
-                if (await this.verify(mode, true))
+            for await (let _ of on(watcher, 'change', { signal: abs })) {
+                try {
+                    await fp.access(this.isAt, expectMode);
                     return;
-                else
-                    await onEachAttempt?.();
+                }
+                catch (err) {
+                    await cb_?.(err);
+                }
+            }
+        }
+        catch (e) {
+            throw e;
         }
         finally {
             watcher.close();
         }
     }
-    async onChange(abs, cb) {
+    /**
+     * Watches the current entry for changes and resolves when the entry is changed.
+     *
+     * @param abs_ An {@link AbortSignal} that stops the watching process when aborted.
+     * @param cb_ An optional callback function that will be called when the entry is changed.
+     * @returns The return value of the callback function, or null if no callback is provided.
+     */
+    async onChange(abs_, cb_) {
         const watcher = fs.watch(this.isAt);
         try {
-            for await (let _ of on(watcher, 'change', { signal: abs }))
-                return await cb?.() || null;
+            for await (let _ of on(watcher, 'change', { signal: abs_ }))
+                return await cb_?.() ?? null;
             return null;
         }
         catch (e) {
@@ -245,285 +211,295 @@ export class Road {
             watcher.close();
         }
     }
-    metaSync(suffixID = "tsInstrumentalityMeta") {
-        if (os.platform() === "win32")
-            return fs.readFileSync(`${this.isAt}:${suffixID}`);
-        else
-            throw new RdErr("Extended attributes are not supported on this platform");
-    }
-    async meta(suffixID = "tsInstrumentalityMeta") {
-        if (os.platform() === "win32")
-            return JSON.parse(await fp.readFile(`${this.isAt}:${suffixID}`, 'utf-8'));
-        else
-            throw new RdErr("Extended attributes are not supported on this platform");
-    }
-    setMetaSync(meta, suffixID = "tsInstrumentalityMeta") {
-        using _ = this.initChangeSync();
-        if (os.platform() === "win32")
-            fs.writeFileSync(`${this.isAt}:${suffixID}`, JSON.stringify(meta), 'utf-8');
-        else
-            throw new RdErr("Extended attributes are not supported on this platform");
-    }
-    async setMeta(meta, suffixID = "tsInstrumentalityMeta") {
-        using _ = await this.initChange();
-        if (os.platform() === "win32")
-            await fp.writeFile(`${this.isAt}:${suffixID}`, JSON.stringify(meta), 'utf-8');
-        else
-            throw new RdErr("Extended attributes are not supported on this platform");
-    }
+    /** @returns The result of {@link fp.lstat} for the current entry. */
+    lstat() { return fp.lstat(this.isAt); }
+    /** @returns The result of {@link fs.lstatSync} for the current entry. */
+    lstatSync() { return fs.lstatSync(this.isAt); }
+    /** @returns The result of {@link fp.stat} for the current entry. */
+    stat() { return fp.stat(this.isAt); }
+    /** @returns The result of {@link fs.statSync} for the current entry. */
+    statSync() { return fs.statSync(this.isAt); }
+    /** Type narrowing for {@link File} (similar to `instanceof` without unnecessary runtime checks). */
+    isFile() { return false; }
+    /** Type narrowing for {@link Folder} (similar to `instanceof` without unnecessary runtime checks). */
+    isDir() { return false; }
+    /** Type narrowing for {@link Folder} (similar to `instanceof` without unnecessary runtime checks). */
+    isFolder() { return false; }
+    /** Type narrowing for {@link Folder} (similar to `instanceof` without unnecessary runtime checks). */
+    isDirectory() { return false; }
+    /** Type narrowing for {@link Folder} (similar to `instanceof` without unnecessary runtime checks). */
+    isDict() { return false; }
+    /** Type narrowing for {@link Folder} (similar to `instanceof` without unnecessary runtime checks). */
+    isDictionary() { return false; }
+    /** Type narrowing for {@link SymbolicLink} (similar to `instanceof` without unnecessary runtime checks). */
+    isSymlink() { return false; }
+    /** Type narrowing for {@link SymbolicLink} (similar to `instanceof` without unnecessary runtime checks). */
+    isSymbolicLink() { return false; }
+    /** Type narrowing for {@link UnusableRoad} (similar to `instanceof` without unnecessary runtime checks). */
+    isUnusable() { return false; }
+    /** Type narrowing for {@link BlockDevice} (similar to `instanceof` without unnecessary runtime checks). */
+    isBlockDevice() { return false; }
+    /** Type narrowing for {@link CharacterDevice} (similar to `instanceof` without unnecessary runtime checks). */
+    isCharacterDevice() { return false; }
+    /** Type narrowing for {@link Fifo} (similar to `instanceof` without unnecessary runtime checks). */
+    isFifo() { return false; }
+    /** Type narrowing for {@link Socket} (similar to `instanceof` without unnecessary runtime checks). */
+    isSocket() { return false; }
 }
+/** Subclass of {@link Road} that represents a file. */
 export class File extends Road {
-    get ext() { return ph.extname(this.isAt); }
-    get noExt() { return ph.basename(this.isAt, this.ext); }
-    static createSync(at) {
+    static async create(at_) {
         try {
-            fs.accessSync(at, fsc.W_OK);
+            await fp.access(at_, fsc.W_OK);
         }
         catch {
-            fs.writeFileSync(at, "");
+            await fp.writeFile(at_, "");
         }
-        return new File(at, false);
+        return new File(at_, true);
     }
-    static async create(at) {
+    static createSync(at_) {
         try {
-            await fp.access(at, fsc.W_OK);
+            fs.accessSync(at_, fs.constants.W_OK);
         }
         catch {
-            await fp.writeFile(at, "");
+            fs.writeFileSync(at_, "");
         }
-        return new File(at, false);
+        return new File(at_, true);
     }
-    readSync(encoding, flag) {
-        if (encoding)
-            return fs.readFileSync(this.isAt, { encoding: encoding, flag: flag });
+    get ext() { return ph.extname(this.isAt); }
+    get noExt() { return ph.basename(this.isAt, this.ext); }
+    async read(encoding_, flag_) {
+        if (encoding_)
+            return fp.readFile(this.isAt, { encoding: encoding_, flag: flag_ });
         else
-            return fs.readFileSync(this.isAt);
+            return fp.readFile(this.isAt);
     }
-    async read(encoding, flag) {
-        if (encoding)
-            return fp.readFile(this.isAt, { encoding: encoding, flag: flag });
+    readSync(encoding_, flag_) {
+        if (encoding_)
+            return fs.readFileSync(this.isAt, { encoding: encoding_, flag: flag_ });
         else
-            return fp.readFile(this.isAt);
+            return fs.readFileSync(this.isAt);
     }
-    // Bizarre reading
-    *itBuffSync(chunkSize = 64 * 1024, flags = 'r', mode) {
-        const fd = fs.openSync(this.isAt, flags, mode);
+    async *itBuff(chunkSize_ = 64 * 1024, flags_ = 'r', mode_) {
+        const fd = await fp.open(this.isAt, flags_, mode_);
         try {
-            const buffer = Buffer.alloc(chunkSize);
+            const buffer = Buffer.alloc(chunkSize_);
             let bytesRead;
             do {
-                bytesRead = fs.readSync(fd, buffer, 0, chunkSize, null);
+                const readResult = await fd.read(buffer, 0, chunkSize_, null);
+                bytesRead = readResult.bytesRead;
                 if (bytesRead > 0)
                     yield buffer.subarray(0, bytesRead);
-            } while (bytesRead === chunkSize);
+            } while (bytesRead === chunkSize_);
         }
         finally {
-            fs.closeSync(fd);
+            await fd.close();
         }
     }
-    async *itBuff(chunkSize = 64 * 1024, flags = 'r', mode) {
-        const fd = await fp.open(this.isAt, flags, mode);
+    *itBuffSync(chunkSize_ = 64 * 1024, flags_ = 'r', mode_) {
+        const fd = fs.openSync(this.isAt, flags_, mode_);
         try {
-            const buffer = Buffer.alloc(chunkSize);
+            const buffer = Buffer.alloc(chunkSize_);
             let bytesRead;
             do {
-                const readResult = await fd.read(buffer, 0, chunkSize, null);
-                bytesRead = readResult.bytesRead;
+                bytesRead = fs.readSync(fd, buffer, 0, chunkSize_, null);
                 if (bytesRead > 0)
                     yield buffer.subarray(0, bytesRead);
-            } while (bytesRead === chunkSize);
-        }
-        finally {
-            await fd.close();
-        }
-    }
-    async *itLines(options = { encoding: 'utf-8' }) {
-        const readStream = fs.createReadStream(this.isAt, options);
-        const rlInterface = rl.createInterface({ input: readStream, crlfDelay: Infinity });
-        try {
-            for await (const line of rlInterface)
-                yield line;
+            } while (bytesRead === chunkSize_);
         }
         finally {
-            rlInterface.close();
-            readStream.destroy();
+            fs.closeSync(fd);
         }
     }
-    computeHashSync(algorithm = "sha256", options, encoding) {
-        const hash = cr.createHash(algorithm, options);
-        for (const chunk of this.itBuffSync())
-            hash.update(chunk);
-        return encoding ? hash.digest(encoding) : hash.digest();
-    }
-    async computeHash(algorithm = "sha256", options, encoding) {
-        const hash = cr.createHash(algorithm, options);
-        for await (const chunk of this.itBuff())
-            hash.update(chunk);
-        return encoding ? hash.digest(encoding) : hash.digest();
-    }
-    async streamHash(algorithm = "sha256", options, encoding) {
-        const hash = cr.createHash(algorithm, options);
-        await sp.pipeline(fs.createReadStream(this.isAt), hash);
-        return encoding ? hash.digest(encoding) : hash.digest();
-    }
-    writeSync(data, options) {
-        using _ = this.initChangeSync();
-        fs.writeFileSync(this.isAt, data, options);
+    async write(data_, options_) {
+        using _ = await this.lock();
+        await fp.writeFile(this.isAt, data_, options_);
     }
-    async write(data, options) {
-        using _ = await this.initChange();
-        await fp.writeFile(this.isAt, data, options);
+    writeSync(data_, options_) {
+        using _ = this.lockSync();
+        fs.writeFileSync(this.isAt, data_, options_);
     }
-    appendSync(data, options) {
-        using _ = this.initChangeSync();
-        fs.appendFileSync(this.isAt, data, options);
+    async append(data_, options_) {
+        using _ = await this.lock();
+        await fp.appendFile(this.isAt, data_, options_);
     }
-    async append(data, options) {
-        using _ = await this.initChange();
-        await fp.appendFile(this.isAt, data, options);
+    appendSync(data_, options_) {
+        using _ = this.lockSync();
+        fs.appendFileSync(this.isAt, data_, options_);
     }
-    async sameAs(other) {
-        if (this.isAt === other.isAt)
-            return true;
-        else if ((await fp.lstat(this.isAt)).size !== (await fp.lstat(other.isAt)).size)
-            return false;
-        const thisIter = this.itBuff();
-        const otherIter = other.itBuff();
-        while (true) {
-            const [a, b] = await Promise.all([thisIter.next(), otherIter.next()]);
-            if (a.done && b.done)
-                return true;
-            if (a.done !== b.done)
-                return false;
-            if (!a.value.equals(b.value))
-                return false;
-        }
-    }
-    sameAsSync(other) {
-        if (this.isAt === other.isAt)
-            return true;
-        else if (fs.statSync(this.isAt).size !== fs.statSync(other.isAt).size)
-            return false;
-        const thisIter = this.itBuffSync();
-        const otherIter = other.itBuffSync();
-        while (true) {
-            const a = thisIter.next();
-            const b = otherIter.next();
-            if (a.done && b.done)
-                return true;
-            if (a.done !== b.done)
-                return false;
-            if (!a.value.equals(b.value))
-                return false;
-        }
+    async delete() {
+        using _ = await this.lock();
+        await fp.rm(this.isAt, { force: true });
     }
     deleteSync() {
-        using _ = this.initChangeSync();
+        using _ = this.lockSync();
         fs.rmSync(this.isAt, { force: true });
     }
-    async delete() {
-        using _ = await this.initChange();
-        await fp.rm(this.isAt, { force: true });
+    async move(into_) {
+        using _ = await this.lock();
+        const newPath = into_.join(this.name);
+        await fp.rename(this.isAt, newPath);
+        this.pointsTo = newPath;
     }
-    moveSync(into) {
-        using _ = this.initChangeSync();
-        const newPath = into.join(this.name);
+    moveSync(into_) {
+        using _ = this.lockSync();
+        const newPath = into_.join(this.name);
         fs.renameSync(this.isAt, newPath);
         this.pointsTo = newPath;
     }
-    async move(into) {
-        using _ = await this.initChange();
-        const newPath = into.join(this.name);
-        await fp.rename(this.isAt, newPath);
-        this.pointsTo = newPath;
+    async copy(into_) {
+        const newPath = into_.join(this.name);
+        await fp.copyFile(this.isAt, newPath);
+        return new File(newPath, false);
     }
-    copySync(into) {
-        const newPath = into.join(this.name);
+    copySync(into_) {
+        const newPath = into_.join(this.name);
         fs.copyFileSync(this.isAt, newPath);
         return new File(newPath, false);
     }
-    async copy(into) {
-        const newPath = into.join(this.name);
-        await fp.copyFile(this.isAt, newPath);
-        return new File(newPath, false);
+    async rename(to_) {
+        using _ = await this.lock();
+        const newPath = this.parent().join(to_);
+        await fp.rename(this.isAt, newPath);
+        this.pointsTo = newPath;
     }
-    renameSync(to) {
-        using _ = this.initChangeSync();
-        const newPath = this.parent().join(to);
+    renameSync(to_) {
+        using _ = this.lockSync();
+        const newPath = this.parent().join(to_);
         fs.renameSync(this.isAt, newPath);
         this.pointsTo = newPath;
     }
-    async rename(to) {
-        using _ = await this.initChange();
-        const newPath = this.parent().join(to);
-        await fp.rename(this.isAt, newPath);
-        this.pointsTo = newPath;
+    async check() { return (await fp.lstat(this.isAt)).isFile(); }
+    checkSync() { return fs.lstatSync(this.isAt).isFile(); }
+    isFile() { return true; }
+}
+export async function computeHash(f_, algorithm_ = "sha256", options_, encoding_) {
+    const hash = cr.createHash(algorithm_, options_);
+    for await (const chunk of f_.itBuff())
+        hash.update(chunk);
+    return encoding_ ? hash.digest(encoding_) : hash.digest();
+}
+export function computeHashSync(f_, algorithm_ = "sha256", options_, encoding_) {
+    const hash = cr.createHash(algorithm_, options_);
+    for (const chunk of f_.itBuffSync())
+        hash.update(chunk);
+    return encoding_ ? hash.digest(encoding_) : hash.digest();
+}
+export async function streamHash(f_, algorithm_ = "sha256", options_, encoding_) {
+    const hash = cr.createHash(algorithm_, options_);
+    for await (const chunk of f_.itBuff())
+        hash.update(chunk);
+    return encoding_ ? hash.digest(encoding_) : hash.digest();
+}
+export function streamHashSync(f_, algorithm_ = "sha256", options_, encoding_) {
+    const hash = cr.createHash(algorithm_, options_);
+    for (const chunk of f_.itBuffSync())
+        hash.update(chunk);
+    return encoding_ ? hash.digest(encoding_) : hash.digest();
+}
+export async function* itLines(f_, options_ = { encoding: 'utf-8' }) {
+    const readStream = fs.createReadStream(f_.isAt, options_);
+    const rlInterface = rl.createInterface({ input: readStream, crlfDelay: Infinity });
+    try {
+        for await (const line of rlInterface)
+            yield line;
     }
-    resurrectSync() {
-        using _ = this.initChangeSync();
-        fs.writeFileSync(this.isAt, "");
+    finally {
+        rlInterface.close();
+        readStream.destroy();
     }
-    async resurrect() {
-        using _ = await this.initChange();
-        await fp.writeFile(this.isAt, "");
+}
+export async function fileSameAs(f1_, f2_) {
+    if (f1_.isAt === f2_.isAt)
+        return true;
+    else if ((await fp.lstat(f1_.isAt)).size !== (await fp.lstat(f2_.isAt)).size)
+        return false;
+    const iter1 = f1_.itBuff();
+    const iter2 = f2_.itBuff();
+    while (true) {
+        const [a, b] = await Promise.all([iter1.next(), iter2.next()]);
+        if (a.done && b.done)
+            return true;
+        if (a.done !== b.done)
+            return false;
+        if (!a.value.equals(b.value))
+            return false;
+    }
+}
+export function fileSameAsSync(f1_, f2_) {
+    if (f1_.isAt === f2_.isAt)
+        return true;
+    else if (fs.statSync(f1_.isAt).size !== fs.statSync(f2_.isAt).size)
+        return false;
+    const iter1 = f1_.itBuffSync();
+    const iter2 = f2_.itBuffSync();
+    while (true) {
+        const a = iter1.next();
+        const b = iter2.next();
+        if (a.done && b.done)
+            return true;
+        if (a.done !== b.done)
+            return false;
+        if (!a.value.equals(b.value))
+            return false;
     }
 }
-export function entry() { return new File(process.argv[1], false); }
 export class Folder extends Road {
-    static async create(at) {
+    static async create(at_) {
         try {
-            await fp.access(at, fs.constants.F_OK);
+            await fp.access(at_, fsc.W_OK);
         }
         catch {
-            await fp.mkdir(at, { recursive: true });
+            await fp.mkdir(at_, { recursive: true });
         }
-        return new Folder(at, false);
+        return new Folder(at_, false);
     }
-    static createSync(at) {
+    static createSync(at_) {
         try {
-            fs.accessSync(at, fs.constants.F_OK);
+            fs.accessSync(at_, fsc.W_OK);
         }
         catch {
-            fs.mkdirSync(at, { recursive: true });
+            fs.mkdirSync(at_, { recursive: true });
         }
-        return new Folder(at, false);
+        return new Folder(at_, false);
     }
-    join(...paths) {
-        return ph.join(this.isAt, ...paths);
+    join(...paths_) {
+        return ph.join(this.isAt, ...paths_);
     }
-    *itSync(expectedType) {
-        for (const entry of fs.readdirSync(this.isAt)) {
-            const road = factorySync(this.join(entry));
-            if (!expectedType || road instanceof expectedType)
+    async *it(expectedType_) {
+        for (const entryName of await fp.readdir(this.isAt)) {
+            const road = await factory(this.join(entryName));
+            if (!expectedType_ || road instanceof expectedType_)
                 yield road;
         }
     }
-    async *it(expectedType) {
-        for (const entry of await fp.readdir(this.isAt)) {
-            const road = await factory(this.join(entry));
-            if (!expectedType || road instanceof expectedType)
+    *itSync(expectedType_) {
+        for (const entry of fs.readdirSync(this.isAt)) {
+            const road = factorySync(this.join(entry));
+            if (!expectedType_ || road instanceof expectedType_)
                 yield road;
         }
     }
-    listSync(expectedType) {
-        const entries = fs.readdirSync(this.isAt).map(entry => factorySync(this.join(entry)));
-        if (!expectedType)
-            return entries;
-        return entries.filter(entry => entry instanceof expectedType);
-    }
-    async list(_expectedType) {
+    async list(expectedType_) {
         const entries = (await fp.readdir(this.isAt)).map(async (entry) => factory(this.join(entry)));
         const resolvedEntries = await Promise.all(entries);
-        if (!_expectedType)
+        if (!expectedType_)
             return resolvedEntries;
-        return resolvedEntries.filter(entry => entry instanceof _expectedType);
+        return resolvedEntries.filter(entry => entry instanceof expectedType_);
     }
-    findSync(name, _expectedType) {
+    listSync(expectedType_) {
+        const entries = fs.readdirSync(this.isAt).map(entry => factorySync(this.join(entry)));
+        if (!expectedType_)
+            return entries;
+        return entries.filter(entry => entry instanceof expectedType_);
+    }
+    async find(name_, expectedType_) {
         try {
-            const found = factorySync(this.join(name));
-            if (!_expectedType)
+            await fp.access(this.join(name_), fs.constants.F_OK);
+            const found = await factory(this.join(name_));
+            if (!expectedType_)
                 return found;
-            if (found instanceof _expectedType)
+            if (found instanceof expectedType_)
                 return found;
             return null;
         }
@@ -531,13 +507,12 @@ export class Folder extends Road {
             return null;
         }
     }
-    async find(name, _expectedType) {
+    findSync(name_, expectedType_) {
         try {
-            await fp.access(this.join(name), fs.constants.F_OK);
-            const found = await factory(this.join(name));
-            if (!_expectedType)
+            const found = factorySync(this.join(name_));
+            if (!expectedType_)
                 return found;
-            if (found instanceof _expectedType)
+            if (found instanceof expectedType_)
                 return found;
             return null;
         }
@@ -545,66 +520,65 @@ export class Folder extends Road {
             return null;
         }
     }
-    addSync(name, createable) {
-        const newPath = this.join(name);
-        createable.createSync(newPath);
-        return factorySync(newPath);
-    }
-    async add(name, createable) {
-        const newPath = this.join(name);
-        await createable.create(newPath);
-        return factory(newPath);
+    async add(name_, createable_) {
+        const newPath = this.join(name_);
+        await createable_.create(newPath);
+        return (await factory(newPath));
     }
-    deleteSync(options = { recursive: true }) {
-        using _ = this.initChangeSync();
-        fs.rmSync(this.isAt, options);
+    addSync(name_, createable_) {
+        const newPath = this.join(name_);
+        createable_.createSync(newPath);
+        return factorySync(newPath);
     }
-    async delete(options = { recursive: true }) {
-        using _ = await this.initChange();
-        await fp.rm(this.isAt, options);
+    async delete(options_ = { recursive: true }) {
+        using _ = await this.lock();
+        await fp.rm(this.isAt, options_);
     }
-    moveSync(into) {
-        using _ = this.initChangeSync();
-        const newPath = into.join(this.name);
-        fs.renameSync(this.isAt, newPath);
-        this.pointsTo = newPath;
+    deleteSync(options_ = { recursive: true }) {
+        using _ = this.lockSync();
+        fs.rmSync(this.isAt, options_);
     }
-    async move(into) {
-        using _ = await this.initChange();
-        const newPath = into.join(this.name);
+    async move(into_) {
+        using _ = await this.lock();
+        const newPath = into_.join(this.name);
         await fp.rename(this.isAt, newPath);
         this.pointsTo = newPath;
     }
-    copySync(into) {
-        const newPath = into.join(this.name);
-        fs.cpSync(this.isAt, newPath, { recursive: true });
-        return new Folder(newPath, false);
+    moveSync(into_) {
+        using _ = this.lockSync();
+        const newPath = into_.join(this.name);
+        fs.renameSync(this.isAt, newPath);
+        this.pointsTo = newPath;
     }
-    async copy(into) {
-        const newPath = into.join(this.name);
+    async copy(into_) {
+        const newPath = into_.join(this.name);
         await fp.cp(this.isAt, newPath, { recursive: true });
         return new Folder(newPath, false);
     }
-    renameSync(to) {
-        using _ = this.initChangeSync();
-        const newPath = this.parent().join(to);
-        fs.renameSync(this.isAt, newPath);
-        this.pointsTo = newPath;
+    copySync(into_) {
+        const newPath = into_.join(this.name);
+        fs.cpSync(this.isAt, newPath, { recursive: true });
+        return new Folder(newPath, false);
     }
-    async rename(to) {
-        using _ = await this.initChange();
-        const newPath = this.parent().join(to);
+    async rename(to_) {
+        using _ = await this.lock();
+        const newPath = this.parent().join(to_);
         await fp.rename(this.isAt, newPath);
         this.pointsTo = newPath;
     }
-    resurrectSync() {
-        using _ = this.initChangeSync();
-        fs.mkdirSync(this.isAt, { recursive: true });
-    }
-    async resurrect() {
-        using _ = await this.initChange();
-        await fp.mkdir(this.isAt, { recursive: true });
+    renameSync(to_) {
+        using _ = this.lockSync();
+        const newPath = this.parent().join(to_);
+        fs.renameSync(this.isAt, newPath);
+        this.pointsTo = newPath;
     }
+    async check() { return (await fp.lstat(this.isAt)).isDirectory(); }
+    checkSync() { return fs.lstatSync(this.isAt).isDirectory(); }
+    isFolder() { return true; }
+    isDir() { return true; }
+    isDirectory() { return true; }
+    isDict() { return true; }
+    isDictionary() { return true; }
 }
 export function sysRoot() { return new Folder(ph.parse(process.cwd()).root, false); }
 export function home() { return new Folder(os.homedir(), false); }
@@ -612,131 +586,134 @@ export function tmp() { return new Folder(os.tmpdir(), false); }
 export function here() { return new Folder(process.cwd(), false); }
 export { Folder as Dir, Folder as Directory, Folder as Dict, Folder as Dictionary };
 export class SymbolicLink extends Road {
-    static async create(at, target) {
+    static async create(at_, target_) {
         try {
-            await fp.access(at, fs.constants.F_OK);
+            await fp.access(at_, fs.constants.F_OK);
         }
         catch {
-            await fp.symlink(target.isAt, at);
+            await fp.symlink(target_.toString(), at_);
         }
-        return new SymbolicLink(at, false);
+        return new SymbolicLink(at_, false);
     }
-    static createSync(_at, _target) {
+    static createSync(at_, target_) {
         try {
-            fs.accessSync(_at, fs.constants.F_OK);
+            fs.accessSync(at_, fs.constants.F_OK);
         }
         catch {
-            fs.symlinkSync(_target.isAt, _at);
+            fs.symlinkSync(target_.toString(), at_);
         }
-        return new SymbolicLink(_at, false);
-    }
-    targetSync() {
-        return factorySync(ph.resolve(ph.dirname(this.isAt), fs.readlinkSync(this.isAt)));
+        return new SymbolicLink(at_, false);
     }
     async target() {
         return factory(ph.resolve(ph.dirname(this.isAt), await fp.readlink(this.isAt)));
     }
-    retargetSync(_newTarget) {
-        this.deleteSync();
-        fs.symlinkSync(_newTarget.isAt, this.isAt);
+    targetSync() {
+        return factorySync(ph.resolve(ph.dirname(this.isAt), fs.readlinkSync(this.isAt)));
     }
-    async retarget(_newTarget) {
+    async retarget(to_) {
         await this.delete();
-        return fp.symlink(_newTarget.isAt, this.isAt);
+        return fp.symlink(to_.isAt, this.isAt);
     }
-    deleteSync() {
-        using _ = this.initChangeSync();
-        fs.unlinkSync(this.isAt);
+    retargetSync(to_) {
+        this.deleteSync();
+        fs.symlinkSync(to_.isAt, this.isAt);
     }
     async delete() {
-        using _ = await this.initChange();
+        using _ = await this.lock();
         await fp.unlink(this.isAt);
     }
-    moveSync(_into) {
-        using _ = this.initChangeSync();
-        const newPath = _into.join(this.name);
-        fs.renameSync(this.isAt, newPath);
-        this.pointsTo = newPath;
+    deleteSync() {
+        using _ = this.lockSync();
+        fs.unlinkSync(this.isAt);
     }
-    async move(_into) {
-        using _ = await this.initChange();
-        const newPath = _into.join(this.name);
+    async move(into_) {
+        using _ = await this.lock();
+        const newPath = into_.join(this.name);
         await fp.rename(this.isAt, newPath);
         this.pointsTo = newPath;
     }
-    copySync(_into) {
-        const newPath = _into.join(this.name);
-        const target = this.targetSync();
-        fs.symlinkSync(target.isAt, newPath);
-        return new SymbolicLink(newPath, false);
+    moveSync(into_) {
+        using _ = this.lockSync();
+        const newPath = into_.join(this.name);
+        fs.renameSync(this.isAt, newPath);
+        this.pointsTo = newPath;
     }
-    async copy(_into) {
-        const newPath = _into.join(this.name);
+    async copy(into_) {
+        const newPath = into_.join(this.name);
         const target = await this.target();
         await fp.symlink(target.isAt, newPath);
         return new SymbolicLink(newPath, false);
     }
-    renameSync(_to) {
-        using _ = this.initChangeSync();
-        const newPath = this.parent().join(_to);
-        fs.renameSync(this.isAt, newPath);
-        this.pointsTo = newPath;
+    copySync(into_) {
+        const newPath = into_.join(this.name);
+        const target = this.targetSync();
+        fs.symlinkSync(target.isAt, newPath);
+        return new SymbolicLink(newPath, false);
     }
-    async rename(_to) {
-        using _ = await this.initChange();
-        const newPath = this.parent().join(_to);
+    async rename(to_) {
+        using _ = await this.lock();
+        const newPath = this.parent().join(to_);
         await fp.rename(this.isAt, newPath);
         this.pointsTo = newPath;
     }
-    resurrectSync() {
-        using _ = this.initChangeSync();
-        const target = this.targetSync();
-        fs.symlinkSync(target.isAt, this.isAt);
-    }
-    async resurrect() {
-        using _ = await this.initChange();
-        const target = await this.target();
-        await fp.symlink(target.isAt, this.isAt);
+    renameSync(to_) {
+        using _ = this.lockSync();
+        const newPath = this.parent().join(to_);
+        fs.renameSync(this.isAt, newPath);
+        this.pointsTo = newPath;
     }
+    async check() { return (await fp.lstat(this.isAt)).isSymbolicLink(); }
+    checkSync() { return fs.lstatSync(this.isAt).isSymbolicLink(); }
+    isSymlink() { return true; }
+    isSymbolicLink() { return true; }
 }
 export { SymbolicLink as Symlink };
 export class UnusableRoad extends Road {
-    mutable = false; // Modification is most likely to cause system issues (e.g. deleting a device file)
-    constructor(_at, typeCheck) {
-        super(_at, typeCheck);
+    mutable = false; // Modification will cause system issues (e.g. deleting a device file)
+    constructor(...args_) {
+        super(...args_);
         Object.freeze(this);
     }
-    error() { throw new RdErr(`${this.constructor.name} at '${this.isAt}' is a system-level resource thus intentionally made immutable.`); }
-    initChangeSync() { return this.error(); }
-    async initChange() { return this.error(); }
-    deleteSync() { return this.error(); }
+    error() { throw new RdErr(`${this.constructor.name} at '${this.isAt}' is a system-level resource thus not subject to modification.`); }
+    async lock() { return this.error(); }
+    lockSync() { return this.error(); }
     async delete() { return this.error(); }
-    moveSync() { return this.error(); }
+    deleteSync() { return this.error(); }
     async move() { return this.error(); }
-    copySync() { return this.error(); }
+    moveSync() { return this.error(); }
     async copy() { return this.error(); }
-    renameSync() { return this.error(); }
+    copySync() { return this.error(); }
     async rename() { return this.error(); }
-    resurrectSync() { return this.error(); }
-    async resurrect() { return this.error(); }
+    renameSync() { return this.error(); }
+    isUnusable() { return true; }
 }
 export class BlockDevice extends UnusableRoad {
+    async check() { return (await fp.lstat(this.isAt)).isBlockDevice(); }
+    checkSync() { return fs.lstatSync(this.isAt).isBlockDevice(); }
+    isBlockDevice() { return true; }
 }
 export class CharacterDevice extends UnusableRoad {
+    async check() { return (await fp.lstat(this.isAt)).isCharacterDevice(); }
+    checkSync() { return fs.lstatSync(this.isAt).isCharacterDevice(); }
+    isCharacterDevice() { return true; }
 }
 export class Fifo extends UnusableRoad {
+    async check() { return (await fp.lstat(this.isAt)).isFIFO(); }
+    checkSync() { return fs.lstatSync(this.isAt).isFIFO(); }
+    isFifo() { return true; }
 }
 export class Socket extends UnusableRoad {
+    async check() { return (await fp.lstat(this.isAt)).isSocket(); }
+    checkSync() { return fs.lstatSync(this.isAt).isSocket(); }
+    isSocket() { return true; }
 }
-export let finalizer = null;
-export let toDelete = null;
-let exitHandlerRegistered = false;
+let finalizer = null;
+let toDelete = null;
+let exitHandlerRegistered = null;
 /**
  * Forcefully cleans up all files and folders registered for cleanup on exit.
- *
- * @remarks This function is not recommended to be called manually, as it will delete all files and folders registered for cleanup on exit, which may lead to data loss if called at the wrong time. This function is intended to be called automatically when the process exits.
  */
-export function forceCleanupToDelete() {
+function forceCleanupToDelete() {
     for (const path of toDelete ?? [])
         try {
             fs.rmSync(path, { force: true, recursive: true });
@@ -749,24 +726,22 @@ export function forceCleanupToDelete() {
         process.off('exit', forceCleanupToDelete);
     exitHandlerRegistered = false;
 }
-export function registerToCleanup(self) {
-    if (!finalizer)
-        finalizer = new FinalizationRegistry(p => { try {
-            fs.rmSync(p, { force: true, recursive: true });
-        }
-        catch { } ; toDelete?.delete(p); });
-    if (!toDelete)
-        toDelete = new Set();
+export function registerToCleanup(self_) {
+    finalizer ??= new FinalizationRegistry(p => { try {
+        fs.rmSync(p, { force: true, recursive: true });
+    }
+    catch { } ; toDelete?.delete(p); });
+    toDelete ??= new Set();
     if (!exitHandlerRegistered) {
         process.once('exit', forceCleanupToDelete);
         exitHandlerRegistered = true;
     }
-    toDelete.add(self.isAt);
-    finalizer.register(self, self.isAt, self);
+    toDelete.add(self_.isAt);
+    finalizer.register(self_, self_.isAt, self_);
 }
-export function Temp(createable, autoCleanup) {
-    const t = createable.createSync(tmp().join(`instrumentality@${cr.randomUUID()}`));
-    if (autoCleanup)
+export function Temp(createable_, autoCleanup_) {
+    let t = createable_.createSync(tmp().join(`instrumentality@${cr.randomUUID()}`));
+    if (autoCleanup_)
         registerToCleanup(t);
     return Object.freeze(Object.assign(t, {
         [Symbol.dispose]() { try {
@@ -779,3 +754,4 @@ export function Temp(createable, autoCleanup) {
         catch { } toDelete?.delete(t.isAt); finalizer?.unregister(t); }
     }));
 }
+11;