instrumentality 0.0.3 → 0.0.5

package/src/road.ts

@@ -4,28 +4,26 @@ 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.ts"
 
 
 
-/**
- * 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 { override 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: number) {
-  switch (statmode & fsc.S_IFMT) {
+export function resolveMode(statmode_: number): typeof File | typeof Folder | typeof BlockDevice | typeof CharacterDevice | typeof SymbolicLink | typeof Fifo | typeof Socket {
+  switch (statmode_ & fsc.S_IFMT) {
     case fsc.S_IFREG: return File
     case fsc.S_IFDIR: return Folder
     case fsc.S_IFBLK: return BlockDevice
@@ -33,50 +31,49 @@ export function resolveMode(statmode: number) {
     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: string) {
-  fs.accessSync(lookFor, fsc.F_OK)
-  return new (resolveMode(fs.lstatSync(lookFor).mode))(lookFor, false)
+export async function factory(path_: string) {
+  return new (resolveMode((await fp.lstat(path_)).mode))(path_, false)
 }
-/** Async version of {@link factorySync}. */
-export async function factory(lookFor: string) {
-  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_: string) {
+  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.
  * 
- * @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.
- */
-let lockedRoads: Map<string, Promise<void>> | null = null
-/**
- * Getter for the locked roads map.
+ * @key The absolute path of the road that is currently locked.
+ * @value A promise that resolves when the lock on the road is released.
  * 
- * @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 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.
  */
-export function lockFor(roadOrPath: Road | string) {
-  return lockedRoads?.get(roadOrPath.toString())
-}
+export let lockedRoads: Map<string, Promise<void>> | null = null
 
 
 
+/**
+ * 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.
+ * 
+ * @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 abstract 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. */
@@ -86,141 +83,88 @@ export abstract class Road {
   mutable: boolean = 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: string, typeCheck: boolean | 1 | 0) {
-    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: number, typeCheck: boolean): Promise<boolean> {
-    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: number, typeCheck: boolean): boolean {
-    try {
-      fs.accessSync(this.isAt, fsc.F_OK | expectMode)
-      return typeCheck || this instanceof this.typeSync()
-    } catch {
-      return false
-    }
+  constructor(path_: string, typeCheck_: boolean | 1 | 0) {
+    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).
    */
-  protected 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'})`)
+  protected async lock(cb_ = () => {}): Promise<AsyncDisposable & Disposable> {
     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<string, Promise<void>>()
-    const lockedPath = this.isAt
-    let releaseLock = () => {}
-    await lockFor(lockedPath)
-    lockedRoads.set(lockedPath, new Promise<void>(res => releaseLock = res))
+      throw new RdErr(`Road to '${this.isAt}' is immutable.`)
+    lockedRoads ??= new Map<string, Promise<void>>()
+    const isAt = this.isAt
+    await lockedRoads.get(isAt) // will skip if `undefined` (no lock)
+    lockedRoads.set(isAt, new Promise<void>(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.
    */
-  protected 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'})`)
+  protected lockSync(cb_ = () => {}): Disposable & AsyncDisposable {
     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<string, Promise<void>>()
-    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<void>(res => releaseLock = res))
+      throw new RdErr(`Road to '${this.isAt}' is immutable.`)
+    lockedRoads ??= new Map<string, Promise<void>>()
+    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<void>(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(): Folder { 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: Folder = this.parent()
     let parent = current.parent()
@@ -230,361 +174,389 @@ export abstract class Road {
       parent = current.parent()
     }
   }
-  ancestors() { return [...this.ancestorsIt()] }
+  /** @returns An array of {@link Folder} instances representing the ancestors of the current road. */
+  ancestors(): Folder[] { return [...this.ancestorsIt()] }
 
-  async untilAccessible(mode = fsc.F_OK, abs: AbortSignal, onEachAttempt?: () => unknown) {
+  /**
+   * 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: AbortSignal, expectMode = fsc.F_OK, cb_?: (err: unknown) => unknown): Promise<void> {
     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?.()
-    } finally {
-      watcher.close()
+        }
+        catch(err: unknown) { await cb_?.(err) }
+      }
     }
+    catch(e) { throw e }
+    finally { watcher.close() }
   }
-  async onChange<T>(abs: AbortSignal, cb?: () => T) {
+  /**
+   * 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<T>(abs_: AbortSignal, cb_?: () => T) {
     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) { throw e }
     finally { 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"): Promise<Record<string, unknown>> {
-    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: Record<string, unknown>, 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: Record<string, unknown>, 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) }
 
-  abstract deleteSync(): void
+  // jsdocs for the abstract methods are in the subclasses
   abstract delete(): Promise<void>
-  abstract moveSync(into: Folder): void
-  abstract move(into: Folder): Promise<void>
-  abstract copySync(into: Folder): this
-  abstract copy(into: Folder): Promise<this>
-  abstract renameSync(to: string): void
-  abstract rename(to: string): Promise<void>
-  abstract resurrectSync(): void
-  abstract resurrect(): Promise<void>
+  abstract deleteSync(): void
+  abstract moveSync(into_: Folder): void
+  abstract move(into_: Folder): Promise<void>
+  abstract copySync(into_: Folder): this
+  abstract copy(into_: Folder): Promise<this>
+  abstract renameSync(to_: string): void
+  abstract rename(to_: string): Promise<void>
+
+  // jsdocs for the abstract methods are in the subclasses
+  abstract check(): Promise<boolean>
+  abstract checkSync(): boolean
+
+  /** Type narrowing for {@link File} (similar to `instanceof` without unnecessary runtime checks). */
+  isFile(): this is File { return false as const }
+  /** Type narrowing for {@link Folder} (similar to `instanceof` without unnecessary runtime checks). */
+  isDir(): this is Folder { return false as const }
+  /** Type narrowing for {@link Folder} (similar to `instanceof` without unnecessary runtime checks). */
+  isFolder(): this is Folder { return false as const }
+  /** Type narrowing for {@link Folder} (similar to `instanceof` without unnecessary runtime checks). */
+  isDirectory(): this is Folder { return false as const }
+  /** Type narrowing for {@link Folder} (similar to `instanceof` without unnecessary runtime checks). */
+  isDict(): this is Folder { return false as const }
+  /** Type narrowing for {@link Folder} (similar to `instanceof` without unnecessary runtime checks). */
+  isDictionary(): this is Folder { return false as const }
+  /** Type narrowing for {@link SymbolicLink} (similar to `instanceof` without unnecessary runtime checks). */
+  isSymlink(): this is SymbolicLink { return false as const }
+  /** Type narrowing for {@link SymbolicLink} (similar to `instanceof` without unnecessary runtime checks). */
+  isSymbolicLink(): this is SymbolicLink { return false as const }
+  /** Type narrowing for {@link UnusableRoad} (similar to `instanceof` without unnecessary runtime checks). */
+  isUnusable(): this is UnusableRoad { return false as const }
+  /** Type narrowing for {@link BlockDevice} (similar to `instanceof` without unnecessary runtime checks). */
+  isBlockDevice(): this is BlockDevice { return false as const }
+  /** Type narrowing for {@link CharacterDevice} (similar to `instanceof` without unnecessary runtime checks). */
+  isCharacterDevice(): this is CharacterDevice { return false as const }
+  /** Type narrowing for {@link Fifo} (similar to `instanceof` without unnecessary runtime checks). */
+  isFifo(): this is Fifo { return false as const }
+  /** Type narrowing for {@link Socket} (similar to `instanceof` without unnecessary runtime checks). */
+  isSocket(): this is Socket { return false as const }
 }
+export type road_t = ConstructorParameters<typeof Road>
 
 
 
+/** Subclass of {@link Road} that represents a file. */
 export class File extends Road {
+  static async create(at_: string) {
+    try { await fp.access(at_, fsc.W_OK) }
+    catch { await fp.writeFile(at_, "") }
+    return new File(at_, true)
+  }
+  static createSync(at_: string) {
+    try { fs.accessSync(at_, fs.constants.W_OK) }
+    catch { fs.writeFileSync(at_, "") }
+    return new File(at_, true)
+  }
+
   get ext() { return ph.extname(this.isAt) }
   get noExt() { return ph.basename(this.isAt, this.ext) }
 
-  static createSync(at: string) {
-    try {
-      fs.accessSync(at, fsc.W_OK)
-    } catch {
-      fs.writeFileSync(at, "")
-    }
-    return new File(at, false)
-  }
-  static async create(at: string) {
-    try {
-      await fp.access(at, fsc.W_OK)
-    } catch {
-      await fp.writeFile(at, "")
-    }
-    return new File(at, false)
+  async read(): Promise<Buffer>
+  async read(encoding_: BufferEncoding, flag_?: string): Promise<string>
+  async read(encoding_?: BufferEncoding, flag_?: string): Promise<Buffer | string> {
+    if (encoding_)
+      return fp.readFile(this.isAt, { encoding: encoding_, flag: flag_ })
+    else
+      return fp.readFile(this.isAt)
   }
-
   readSync(): Buffer
-  readSync(encoding: BufferEncoding, flag?: string): string
-  readSync(encoding?: BufferEncoding, flag?: string): Buffer | string {
-    if (encoding)
-      return fs.readFileSync(this.isAt, { encoding: encoding, flag: flag })
+  readSync(encoding_: BufferEncoding, flag_?: string): string
+  readSync(encoding_?: BufferEncoding, flag_?: string): Buffer | string {
+    if (encoding_)
+      return fs.readFileSync(this.isAt, { encoding: encoding_, flag: flag_ })
     else
       return fs.readFileSync(this.isAt)
   }
-  async read(): Promise<Buffer>
-  async read(encoding: BufferEncoding, flag?: string): Promise<string>
-  async read(encoding?: BufferEncoding, flag?: string): Promise<Buffer | string> {
-    if (encoding)
-      return fp.readFile(this.isAt, { encoding: encoding, flag: flag })
-    else
-      return fp.readFile(this.isAt)
-  }
 
-  // Bizarre reading
-  *itBuffSync(chunkSize: number = 64 * 1024, flags: string | number = 'r', mode?: fs.Mode) {
-    const fd = fs.openSync(this.isAt, flags, mode)
+  async *itBuff(chunkSize_: number = 64 * 1024, flags_: string | number = 'r', mode_?: fs.Mode) {
+    const fd = await fp.open(this.isAt, flags_, mode_)
     try {
-      const buffer = Buffer.alloc(chunkSize)
+      const buffer = Buffer.alloc(chunkSize_)
       let bytesRead: number
       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: number = 64 * 1024, flags: string | number = 'r', mode?: fs.Mode) {
-    const fd = await fp.open(this.isAt, flags, mode)
+  *itBuffSync(chunkSize_: number = 64 * 1024, flags_: string | number = 'r', mode_?: fs.Mode) {
+    const fd = fs.openSync(this.isAt, flags_, mode_)
     try {
-      const buffer = Buffer.alloc(chunkSize)
+      const buffer = Buffer.alloc(chunkSize_)
       let bytesRead: number
       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)
+      } while (bytesRead === chunkSize_)
     } finally {
-      await fd.close()
+      fs.closeSync(fd)
     }
   }
-  async *itLines(options: Parameters<typeof fs.createReadStream>[1] = { 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
-    } finally {
-      rlInterface.close()
-      readStream.destroy()
-    }
+
+  async write(data_: Buffer | string, options_?: fs.WriteFileOptions) {
+    using _ = await this.lock()
+    await fp.writeFile(this.isAt, data_, options_)
   }
-  computeHashSync(algorithm?: string, options?: cr.HashOptions): Buffer
-  computeHashSync(algorithm?: string, options?: cr.HashOptions, encoding?: BufferEncoding): string
-  computeHashSync(algorithm = "sha256", options?: cr.HashOptions, encoding?: BufferEncoding): Buffer | string {
-    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?: string, options?: cr.HashOptions): Promise<Buffer>
-  async computeHash(algorithm?: string, options?: cr.HashOptions, encoding?: BufferEncoding): Promise<string>
-  async computeHash(algorithm = "sha256", options?: cr.HashOptions, encoding?: BufferEncoding): Promise<Buffer | string> {
-    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?: cr.HashOptions, encoding?: BufferEncoding): Promise<Buffer | string> {
-    const hash = cr.createHash(algorithm, options)
-    await sp.pipeline(fs.createReadStream(this.isAt), hash)
-    return encoding ? hash.digest(encoding) : hash.digest()
-  }
-
-  writeSync(data: Buffer | string, options?: fs.WriteFileOptions) {
-    using _ = this.initChangeSync()
-    fs.writeFileSync(this.isAt, data, options)
-  }
-  async write(data: Buffer | string, options?: fs.WriteFileOptions) {
-    using _ = await this.initChange()
-    await fp.writeFile(this.isAt, data, options)
-  }
-  appendSync(data: Buffer | string, options?: fs.WriteFileOptions) {
-    using _ = this.initChangeSync()
-    fs.appendFileSync(this.isAt, data, options)
-  }
-  async append(data: Buffer | string, options?: fs.WriteFileOptions) {
-    using _ = await this.initChange()
-    await fp.appendFile(this.isAt, data, options)
-  }
-
-  async sameAs(other: File) {
-    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
-    }
+  writeSync(data_: Buffer | string, options_?: fs.WriteFileOptions) {
+    using _ = this.lockSync()
+    fs.writeFileSync(this.isAt, data_, options_)
   }
-  sameAsSync(other: File) {
-    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 append(data_: Buffer | string, options_?: fs.WriteFileOptions) {
+    using _ = await this.lock()
+    await fp.appendFile(this.isAt, data_, options_)
   }
-
-  deleteSync() {
-    using _ = this.initChangeSync()
-    fs.rmSync(this.isAt, { force: true })
+  appendSync(data_: Buffer | string, options_?: fs.WriteFileOptions) {
+    using _ = this.lockSync()
+    fs.appendFileSync(this.isAt, data_, options_)
   }
+
   async delete() {
-    using _ = await this.initChange()
+    using _ = await this.lock()
     await fp.rm(this.isAt, { force: true })
   }
-  moveSync(into: Folder) {
-    using _ = this.initChangeSync()
-    const newPath = into.join(this.name)
-    fs.renameSync(this.isAt, newPath)
-    this.pointsTo = newPath
+  deleteSync() {
+    using _ = this.lockSync()
+    fs.rmSync(this.isAt, { force: true })
   }
-  async move(into: Folder) {
-    using _ = await this.initChange()
-    const newPath = into.join(this.name)
+  async move(into_: Folder) {
+    using _ = await this.lock()
+    const newPath = into_.join(this.name)
     await fp.rename(this.isAt, newPath)
     this.pointsTo = newPath
   }
-  copySync(into: Folder): this {
-    const newPath = into.join(this.name)
-    fs.copyFileSync(this.isAt, newPath)
-    return new File(newPath, false) as this
+  moveSync(into_: Folder) {
+    using _ = this.lockSync()
+    const newPath = into_.join(this.name)
+    fs.renameSync(this.isAt, newPath)
+    this.pointsTo = newPath
   }
-  async copy(into: Folder): Promise<this> {
-    const newPath = into.join(this.name)
+  async copy(into_: Folder): Promise<this> {
+    const newPath = into_.join(this.name)
     await fp.copyFile(this.isAt, newPath)
     return new File(newPath, false) as this
   }
-  renameSync(to: string) {
-    using _ = this.initChangeSync()
-    const newPath = this.parent().join(to)
-    fs.renameSync(this.isAt, newPath)
-    this.pointsTo = newPath
+  copySync(into_: Folder): this {
+    const newPath = into_.join(this.name)
+    fs.copyFileSync(this.isAt, newPath)
+    return new File(newPath, false) as this
   }
-  async rename(to: string) {
-    using _ = await this.initChange()
-    const newPath = this.parent().join(to)
+  async rename(to_: string) {
+    using _ = await this.lock()
+    const newPath = this.parent().join(to_)
     await fp.rename(this.isAt, newPath)
     this.pointsTo = newPath
   }
-  resurrectSync() {
-    using _ = this.initChangeSync()
-    fs.writeFileSync(this.isAt, "")
+  renameSync(to_: string) {
+    using _ = this.lockSync()
+    const newPath = this.parent().join(to_)
+    fs.renameSync(this.isAt, newPath)
+    this.pointsTo = newPath
   }
-  async resurrect() {
-    using _ = await this.initChange()
-    await fp.writeFile(this.isAt, "")
+
+  async check(): Promise<boolean> { return (await fp.lstat(this.isAt)).isFile() }
+  checkSync(): boolean { return fs.lstatSync(this.isAt).isFile() }
+
+  override isFile(): this is File { return true as const }
+}
+
+
+// Bizarre functions for file I/O
+export async function computeHash(f_: File, algorithm_?: string, options_?: cr.HashOptions): Promise<Buffer>
+export async function computeHash(f_: File, algorithm_?: string, options_?: cr.HashOptions, encoding_?: BufferEncoding): Promise<string>
+export async function computeHash(f_: File, algorithm_ = "sha256", options_?: cr.HashOptions, encoding_?: BufferEncoding): Promise<Buffer | string> {
+  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_: File, algorithm_?: string, options_?: cr.HashOptions): Buffer
+export function computeHashSync(f_: File, algorithm_?: string, options_?: cr.HashOptions, encoding_?: BufferEncoding): string
+export function computeHashSync(f_: File, algorithm_ = "sha256", options_?: cr.HashOptions, encoding_?: BufferEncoding): Buffer | string {
+  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_: File, algorithm_?: string, options_?: cr.HashOptions): Promise<Buffer>
+export async function streamHash(f_: File, algorithm_?: string, options_?: cr.HashOptions, encoding_?: BufferEncoding): Promise<string>
+export async function streamHash(f_: File, algorithm_ = "sha256", options_?: cr.HashOptions, encoding_?: BufferEncoding): Promise<Buffer | string> {
+  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_: File, algorithm_?: string, options_?: cr.HashOptions): Buffer
+export function streamHashSync(f_: File, algorithm_?: string, options_?: cr.HashOptions, encoding_?: BufferEncoding): string
+export function streamHashSync(f_: File, algorithm_ = "sha256", options_?: cr.HashOptions, encoding_?: BufferEncoding): Buffer | string {
+  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_: File, options_: fs.ReadStreamOptions = { 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
+  } finally {
+    rlInterface.close()
+    readStream.destroy()
   }
 }
 
-export function entry() { return new File(process.argv[1]!, false) }
+export async function fileSameAs(f1_: File, f2_: File): Promise<boolean> {
+  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_: File, f2_: File): boolean {
+  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 class Folder extends Road {
-  static async create(at: string): Promise<Folder> {
-    try {
-      await fp.access(at, fs.constants.F_OK)
-    } catch {
-      await fp.mkdir(at, { recursive: true })
-    }
-    return new Folder(at, false)
+  static async create(at_: string) {
+    try { await fp.access(at_, fsc.W_OK) }
+    catch { await fp.mkdir(at_, { recursive: true }) }
+    return new Folder(at_, false)
   }
-  static createSync(at: string): Folder {
-    try {
-      fs.accessSync(at, fs.constants.F_OK)
-    } catch {
-      fs.mkdirSync(at, { recursive: true })
-    }
-    return new Folder(at, false)
+  static createSync(at_: string) {
+    try { fs.accessSync(at_, fsc.W_OK) }
+    catch { fs.mkdirSync(at_, { recursive: true }) }
+    return new Folder(at_, false)
   }
 
-  join(...paths: string[]) {
-    return ph.join(this.isAt, ...paths)
+  join(...paths_: string[]) {
+    return ph.join(this.isAt, ...paths_)
   }
 
-  itSync(): Iterable<Road>
-  itSync<T extends Road>(expectedType: new () => T): Iterable<T>
-  *itSync<T extends Road>(expectedType?: new () => T): Iterable<Road> | Iterable<T> {
-    for (const entry of fs.readdirSync(this.isAt)) {
-      const road = factorySync(this.join(entry))
-      if (!expectedType || road instanceof expectedType)
+  it(): AsyncIterable<Road>
+  it<T extends Road>(expectedType_: new (..._: any[]) => T): AsyncIterable<T>
+  async *it<T extends Road>(expectedType_?: new (..._: any[]) => T): AsyncIterable<Road> | AsyncIterable<T> {
+    for (const entryName of await fp.readdir(this.isAt)) {
+      const road = await factory(this.join(entryName))
+      if (!expectedType_ || road instanceof expectedType_)
         yield road
     }
   }
-  it(): AsyncIterable<Road>
-  it<T extends Road>(expectedType: new () => T): AsyncIterable<T>
-  async *it<T extends Road>(expectedType?: new () => T): AsyncIterable<Road> | AsyncIterable<T> {
-    for (const entry of await fp.readdir(this.isAt)) {
-      const road = await factory(this.join(entry))
-      if (!expectedType || road instanceof expectedType)
+  itSync(): Iterable<Road>
+  itSync<T extends Road>(expectedType_: new (..._: any[]) => T): Iterable<T>
+  *itSync<T extends Road>(expectedType_?: new (..._: any[]) => T): Iterable<Road> | Iterable<T> {
+    for (const entry of fs.readdirSync(this.isAt)) {
+      const road = factorySync(this.join(entry))
+      if (!expectedType_ || road instanceof expectedType_)
         yield road
     }
   }
-  listSync(): Road[]
-  listSync<T extends Road>(expectedType: new () => T): T[]
-  listSync<T extends Road>(expectedType?: new () => T): Road[] | T[] {
-    const entries = fs.readdirSync(this.isAt).map(entry => factorySync(this.join(entry)))
-    if (!expectedType)
-      return entries
-    return entries.filter(entry => entry instanceof expectedType) as unknown as T[]
-  }
   async list(): Promise<Road[]>
-  async list<T extends Road>(_expectedType: new () => T): Promise<T[]>
-  async list<T extends Road>(_expectedType?: new () => T): Promise<Road[] | T[]> {
+  async list<T extends Road>(expectedType_: new (..._: any[]) => T): Promise<T[]>
+  async list<T extends Road>(expectedType_?: new (..._: any[]) => T): Promise<Road[] | T[]> {
     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) as unknown as T[]
+    return resolvedEntries.filter(entry => entry instanceof expectedType_) as unknown as T[]
+  }
+  listSync(): Road[]
+  listSync<T extends Road>(expectedType_: new (..._: any[]) => T): T[]
+  listSync<T extends Road>(expectedType_?: new (..._: any[]) => T): Road[] | T[] {
+    const entries = fs.readdirSync(this.isAt).map(entry => factorySync(this.join(entry)))
+    if (!expectedType_)
+      return entries
+    return entries.filter(entry => entry instanceof expectedType_) as unknown as T[]
   }
 
-  findSync(name: string): Road | null
-  findSync<T extends Road>(name: string, _expectedType: new () => T): T | null
-  findSync<T extends Road>(name: string, _expectedType?: new () => T): Road | T | null {
+  async find(name_: string): Promise<Road | null>
+  async find<T extends Road>(name_: string, expectedType_: new (..._: any[]) => T): Promise<T | null>
+  async find<T extends Road>(name_: string, expectedType_?: new (..._: any[]) => T): Promise<Road | T | null> {
     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 as T
       return null
     } catch {
       return null
     }
   }
-
-  async find(name: string): Promise<Road | null>
-  async find<T extends Road>(name: string, _expectedType: new () => T): Promise<T | null>
-  async find<T extends Road>(name: string, _expectedType?: new () => T): Promise<Road | T | null> {
+  findSync(name_: string): Road | null
+  findSync<T extends Road>(name_: string, expectedType_: new (..._: any[]) => T): T | null
+  findSync<T extends Road>(name_: string, expectedType_?: new (..._: any[]) => T): Road | T | null {
     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 as T
       return null
     } catch {
@@ -592,69 +564,71 @@ export class Folder extends Road {
     }
   }
 
-  addSync<T extends Road>(name: string, createable: { createSync: (at: string) => T }): T {
-    const newPath = this.join(name)
-    createable.createSync(newPath)
-    return factorySync(newPath) as unknown as T
+  async add<T extends Road>(name_: string, createable_: { create: (at: string) => Promise<T> }): Promise<T> {
+    const newPath = this.join(name_)
+    await createable_.create(newPath)
+    return (await factory(newPath)) as unknown as T
   }
-  async add<T extends Road>(name: string, createable: { create: (at: string) => Promise<T> }): Promise<T> {
-    const newPath = this.join(name)
-    await createable.create(newPath)
-    return factory(newPath) as unknown as Promise<T>
+  addSync<T extends Road>(name_: string, createable_: { createSync: (at: string) => T }): T {
+    const newPath = this.join(name_)
+    createable_.createSync(newPath)
+    return factorySync(newPath) as unknown as T
   }
 
-  deleteSync(options: fs.RmOptions = { recursive: true }) {
-    using _ = this.initChangeSync()
-    fs.rmSync(this.isAt, options)
-  }
-  async delete(options: fs.RmOptions = { recursive: true }) {
-    using _ = await this.initChange()
-    await fp.rm(this.isAt, options)
+  async delete(options_: fs.RmOptions = { recursive: true }) {
+    using _ = await this.lock()
+    await fp.rm(this.isAt, options_)
   }
-  moveSync(into: Folder) {
-    using _ = this.initChangeSync()
-    const newPath = into.join(this.name)
-    fs.renameSync(this.isAt, newPath)
-    this.pointsTo = newPath
+  deleteSync(options_: fs.RmOptions = { recursive: true }) {
+    using _ = this.lockSync()
+    fs.rmSync(this.isAt, options_)
   }
-  async move(into: Folder) {
-    using _ = await this.initChange()
-    const newPath = into.join(this.name)
+  async move(into_: Folder) {
+    using _ = await this.lock()
+    const newPath = into_.join(this.name)
     await fp.rename(this.isAt, newPath)
     this.pointsTo = newPath
   }
-  copySync(into: Folder): this {
-    const newPath = into.join(this.name)
-    fs.cpSync(this.isAt, newPath, { recursive: true })
-    return new Folder(newPath, false) as this
+  moveSync(into_: Folder) {
+    using _ = this.lockSync()
+    const newPath = into_.join(this.name)
+    fs.renameSync(this.isAt, newPath)
+    this.pointsTo = newPath
   }
-  async copy(into: Folder): Promise<this> {
-    const newPath = into.join(this.name)
+  async copy(into_: Folder): Promise<this> {
+    const newPath = into_.join(this.name)
     await fp.cp(this.isAt, newPath, { recursive: true })
     return new Folder(newPath, false) as this
   }
-  renameSync(to: string) {
-    using _ = this.initChangeSync()
-    const newPath = this.parent().join(to)
-    fs.renameSync(this.isAt, newPath)
-    this.pointsTo = newPath
+  copySync(into_: Folder): this {
+    const newPath = into_.join(this.name)
+    fs.cpSync(this.isAt, newPath, { recursive: true })
+    return new Folder(newPath, false) as this
   }
-  async rename(to: string) {
-    using _ = await this.initChange()
-    const newPath = this.parent().join(to)
+  async rename(to_: string) {
+    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_: string) {
+    using _ = this.lockSync()
+    const newPath = this.parent().join(to_)
+    fs.renameSync(this.isAt, newPath)
+    this.pointsTo = newPath
   }
+
+  async check(): Promise<boolean> { return (await fp.lstat(this.isAt)).isDirectory() }
+  checkSync(): boolean { return fs.lstatSync(this.isAt).isDirectory() }
+
+  override isFolder(): this is Folder { return true as const }
+  override isDir(): this is Folder { return true as const }
+  override isDirectory(): this is Folder { return true as const }
+  override isDict(): this is Folder { return true as const }
+  override isDictionary(): this is Folder { return true as const }
 }
 
+
 export function sysRoot() { return new Folder(ph.parse(process.cwd()).root, false) }
 export function home() { return new Folder(os.homedir(), false) }
 export function tmp() { return new Folder(os.tmpdir(), false) }
@@ -664,133 +638,137 @@ export { Folder as Dir, Folder as Directory, Folder as Dict, Folder as Dictionar
 
 
 export class SymbolicLink extends Road {
-  static async create(at: string, target: Road) {
-    try {
-      await fp.access(at, fs.constants.F_OK)
-    } catch {
-      await fp.symlink(target.isAt, at)
-    }
-    return new SymbolicLink(at, false)
+  static async create(at_: string, target_: string | Road) {
+    try { await fp.access(at_, fs.constants.F_OK) }
+    catch { await fp.symlink(target_.toString(), at_) }
+    return new SymbolicLink(at_, false)
   }
-  static createSync(_at: string, _target: Road) {
-    try {
-      fs.accessSync(_at, fs.constants.F_OK)
-    } catch {
-      fs.symlinkSync(_target.isAt, _at)
-    }
-    return new SymbolicLink(_at, false)
+  static createSync(at_: string, target_: string | Road) {
+    try { fs.accessSync(at_, fs.constants.F_OK) }
+    catch { fs.symlinkSync(target_.toString(), at_) }
+    return new SymbolicLink(at_, false)
   }
 
-  targetSync() {
-    return factorySync(ph.resolve(ph.dirname(this.isAt), fs.readlinkSync(this.isAt)))
-  }
   async target() {
     return factory(ph.resolve(ph.dirname(this.isAt), await fp.readlink(this.isAt)))
   }
-  retargetSync(_newTarget: Road) {
-    this.deleteSync()
-    fs.symlinkSync(_newTarget.isAt, this.isAt)
+  targetSync() {
+    return factorySync(ph.resolve(ph.dirname(this.isAt), fs.readlinkSync(this.isAt)))
   }
-  async retarget(_newTarget: Road) {
+  async retarget(to_: Road) {
     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_: Road) {
+    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: Folder) {
-    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: Folder) {
-    using _ = await this.initChange()
-    const newPath = _into.join(this.name)
+  async move(into_: Folder) {
+    using _ = await this.lock()
+    const newPath = into_.join(this.name)
     await fp.rename(this.isAt, newPath)
     this.pointsTo = newPath
   }
-  copySync(_into: Folder): this {
-    const newPath = _into.join(this.name)
-    const target = this.targetSync()
-    fs.symlinkSync(target.isAt, newPath)
-    return new SymbolicLink(newPath, false) as this
+  moveSync(into_: Folder) {
+    using _ = this.lockSync()
+    const newPath = into_.join(this.name)
+    fs.renameSync(this.isAt, newPath)
+    this.pointsTo = newPath
   }
-  async copy(_into: Folder): Promise<this> {
-    const newPath = _into.join(this.name)
+  async copy(into_: Folder): Promise<this> {
+    const newPath = into_.join(this.name)
     const target = await this.target()
     await fp.symlink(target.isAt, newPath)
     return new SymbolicLink(newPath, false) as this
   }
-  renameSync(_to: string) {
-    using _ = this.initChangeSync()
-    const newPath = this.parent().join(_to)
-    fs.renameSync(this.isAt, newPath)
-    this.pointsTo = newPath
+  copySync(into_: Folder): this {
+    const newPath = into_.join(this.name)
+    const target = this.targetSync()
+    fs.symlinkSync(target.isAt, newPath)
+    return new SymbolicLink(newPath, false) as this
   }
-  async rename(_to: string) {
-    using _ = await this.initChange()
-    const newPath = this.parent().join(_to)
+  async rename(to_: string) {
+    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_: string) {
+    using _ = this.lockSync()
+    const newPath = this.parent().join(to_)
+    fs.renameSync(this.isAt, newPath)
+    this.pointsTo = newPath
   }
+
+  async check(): Promise<boolean> { return (await fp.lstat(this.isAt)).isSymbolicLink() }
+  checkSync(): boolean { return fs.lstatSync(this.isAt).isSymbolicLink() }
+
+  override isSymlink(): this is SymbolicLink { return true as const }
+  override isSymbolicLink(): this is SymbolicLink { return true as const }
 }
 export { SymbolicLink as Symlink }
 
 
 
 export abstract class UnusableRoad extends Road {
-  override readonly mutable: boolean = false // Modification is most likely to cause system issues (e.g. deleting a device file)
-  constructor(_at: string, typeCheck: boolean) {
-    super(_at, typeCheck)
+  override readonly mutable: boolean = false // Modification will cause system issues (e.g. deleting a device file)
+  constructor(...args_: ConstructorParameters<typeof Road>) {
+    super(...args_)
     Object.freeze(this)
   }
-  error(): never { throw new RdErr(`${this.constructor.name} at '${this.isAt}' is a system-level resource thus intentionally made immutable.`) }
-  override initChangeSync(): never { return this.error() }
-  override async initChange(): Promise<never> { return this.error() }
-  override deleteSync(): never { return this.error() }
+  error(): never { throw new RdErr(`${this.constructor.name} at '${this.isAt}' is a system-level resource thus not subject to modification.`) }
+  override async lock(): Promise<never> { return this.error() }
+  override lockSync(): never { return this.error() }
   override async delete(): Promise<never> { return this.error() }
-  override moveSync(): never { return this.error() }
+  override deleteSync(): never { return this.error() }
   override async move(): Promise<never> { return this.error() }
-  override copySync(): never { return this.error() }
+  override moveSync(): never { return this.error() }
   override async copy(): Promise<never> { return this.error() }
-  override renameSync(): never { return this.error() }
+  override copySync(): never { return this.error() }
   override async rename(): Promise<never> { return this.error() }
-  override resurrectSync(): never { return this.error() }
-  override async resurrect(): Promise<never> { return this.error() }
+  override renameSync(): never { return this.error() }
+  
+  override isUnusable(): this is UnusableRoad { return true as const }
+}
+export class BlockDevice extends UnusableRoad {
+  async check(): Promise<boolean> { return (await fp.lstat(this.isAt)).isBlockDevice() }
+  checkSync(): boolean { return fs.lstatSync(this.isAt).isBlockDevice() }
+  override isBlockDevice(): this is BlockDevice { return true as const }
+}
+export class CharacterDevice extends UnusableRoad {
+  async check(): Promise<boolean> { return (await fp.lstat(this.isAt)).isCharacterDevice() }
+  checkSync(): boolean { return fs.lstatSync(this.isAt).isCharacterDevice() }
+  override isCharacterDevice(): this is CharacterDevice { return true as const }
+}
+export class Fifo extends UnusableRoad {
+  async check(): Promise<boolean> { return (await fp.lstat(this.isAt)).isFIFO() }
+  checkSync(): boolean { return fs.lstatSync(this.isAt).isFIFO() }
+  override isFifo(): this is Fifo { return true as const }
+}
+export class Socket extends UnusableRoad {
+  async check(): Promise<boolean> { return (await fp.lstat(this.isAt)).isSocket() }
+  checkSync(): boolean { return fs.lstatSync(this.isAt).isSocket() }
+  override isSocket(): this is Socket { return true as const }
 }
-export class BlockDevice extends UnusableRoad { }
-export class CharacterDevice extends UnusableRoad { }
-export class Fifo extends UnusableRoad { }
-export class Socket extends UnusableRoad { }
 
 
 
-export let finalizer: FinalizationRegistry<string> | null = null
-export let toDelete: Set<string> | null = null
-let exitHandlerRegistered = false
+let finalizer: FinalizationRegistry<string> | null = null
+let toDelete: Set<string> | null = null
+let exitHandlerRegistered: boolean | null = 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 }) } catch {}
   toDelete?.clear()
@@ -800,26 +778,24 @@ export function forceCleanupToDelete() {
     process.off('exit', forceCleanupToDelete)
   exitHandlerRegistered = false
 }
-export function registerToCleanup(self: Road) {
-  if (!finalizer)
-    finalizer = new FinalizationRegistry<string>(p => { try { fs.rmSync(p, { force: true, recursive: true }) } catch {}; toDelete?.delete(p) })
-  if (!toDelete)
-    toDelete = new Set()
+export function registerToCleanup(self_: Road) {
+  finalizer ??= new FinalizationRegistry<string>(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<T extends Road>(createable: { createSync: (at: string) => T }, autoCleanup: boolean): T & Disposable & AsyncDisposable {
-  const t = createable.createSync(tmp().join(`instrumentality@${cr.randomUUID()}`))
-  if (autoCleanup)
+export function Temp<T extends Road>(createable_: { createSync: (at: string) => T }, autoCleanup_: boolean): T & Disposable & AsyncDisposable {
+  let t = createable_.createSync(tmp().join(`instrumentality@${cr.randomUUID()}`))
+  if (autoCleanup_)
     registerToCleanup(t)
   return Object.freeze(Object.assign(t, {
     [Symbol.dispose]() { try { t.deleteSync() } catch {} toDelete?.delete(t.isAt); finalizer?.unregister(t) },
     async [Symbol.asyncDispose]() { try { await t.delete() } catch {} toDelete?.delete(t.isAt); finalizer?.unregister(t) }
   }))
-}
+}11