path-class 0.12.2 → 0.13.0

package/dist/lib/path-class/sync/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../src/sync/PathSync.ts"],
-  "sourcesContent": ["import {\n  appendFileSync,\n  chmodSync,\n  cpSync,\n  lstatSync,\n  mkdirSync,\n  mkdtempSync,\n  readdirSync,\n  readFileSync,\n  realpathSync,\n  renameSync,\n  rmdirSync,\n  rmSync,\n  statSync,\n  symlinkSync,\n  writeFileSync,\n} from \"node:fs\";\nimport { constants } from \"node:fs/promises\";\nimport { tmpdir } from \"node:os\";\nimport { mustNotHaveTrailingSlash, Path } from \"../Path\";\nimport type {\n  lstatSyncType,\n  readDirSyncType,\n  readFileSyncType,\n  statSyncType,\n} from \"./modifiedNodeTypes\";\n\nexport class PathSync extends Path {\n  static override fromString(s: string): PathSync {\n    return new PathSync(s);\n  }\n\n  static override resolve(...args: Parameters<typeof Path.resolve>): PathSync {\n    return new PathSync(Path.resolve(...args));\n  }\n\n  override toggleTrailingSlash(\n    ...args: Parameters<Path[\"toggleTrailingSlash\"]>\n  ): PathSync {\n    return new PathSync(super.toggleTrailingSlash(...args));\n  }\n\n  override join(...args: Parameters<Path[\"join\"]>): PathSync {\n    return new PathSync(super.join(...args));\n  }\n\n  override asRelative(...args: Parameters<Path[\"asRelative\"]>): PathSync {\n    return new PathSync(super.asRelative(...args));\n  }\n\n  override asAbsolute(...args: Parameters<Path[\"asAbsolute\"]>): PathSync {\n    return new PathSync(super.asAbsolute(...args));\n  }\n\n  override asBare(...args: Parameters<Path[\"asBare\"]>): PathSync {\n    return new PathSync(super.asBare(...args));\n  }\n\n  override extendBasename(\n    ...args: Parameters<Path[\"extendBasename\"]>\n  ): PathSync {\n    return new PathSync(super.extendBasename(...args));\n  }\n\n  override get parent(): PathSync {\n    return new PathSync(super.parent);\n  }\n\n  override get dirname(): PathSync {\n    return new PathSync(super.dirname);\n  }\n\n  override get basename(): PathSync {\n    return new PathSync(super.basename);\n  }\n\n  static override get homedir(): PathSync {\n    return new PathSync(Path.homedir);\n  }\n\n  static override get cwd(): PathSync {\n    return new PathSync(Path.cwd);\n  }\n\n  override debugPrint(...args: Parameters<Path[\"debugPrint\"]>): PathSync {\n    return new PathSync(super.debugPrint(...args));\n  }\n\n  // TODO: find a neat way to dedup with the async version? // lint-sync-code-expect-error\n  existsSync(constraints?: { mustBe: \"file\" | \"directory\" }): boolean {\n    if (constraints?.mustBe === \"file\") {\n      mustNotHaveTrailingSlash(this);\n    }\n    let stats: ReturnType<typeof statSync>;\n    try {\n      stats = statSync(this.path);\n      // biome-ignore lint/suspicious/noExplicitAny: TypeScript limitation\n    } catch (e: any) {\n      if (e.code === \"ENOENT\") {\n        return false;\n      }\n      throw e;\n    }\n    if (!constraints?.mustBe) {\n      return true;\n    }\n    switch (constraints?.mustBe) {\n      case \"file\": {\n        if (stats.isFile()) {\n          return true;\n        }\n        throw new Error(`PathSync exists but is not a file: ${this.path}`);\n      }\n      case \"directory\": {\n        if (stats.isDirectory()) {\n          return true;\n        }\n        throw new Error(`PathSync exists but is not a directory: ${this.path}`);\n      }\n      default: {\n        throw new Error(\"Invalid path type constraint\");\n      }\n    }\n  }\n\n  existsAsFileSync(): boolean {\n    return this.existsSync({ mustBe: \"file\" });\n  }\n\n  existsAsDirSync(): boolean {\n    return this.existsSync({ mustBe: \"directory\" });\n  }\n\n  mkdirSync(options?: Parameters<typeof mkdirSync>[1]): PathSync {\n    const optionsObject = (() => {\n      if (typeof options === \"string\" || typeof options === \"number\") {\n        return { mode: options };\n      }\n      return options ?? {};\n    })();\n    mkdirSync(this.path, { recursive: true, ...optionsObject });\n    return this;\n  }\n\n  cpSync(\n    destination: string | URL | Path,\n    options?: Parameters<typeof cpSync>[2] & {\n      createIntermediateDirs?: boolean;\n    },\n  ): PathSync {\n    const { createIntermediateDirs, ...cpOptions } = options ?? {};\n    const destinationPath = new PathSync(destination);\n    if (createIntermediateDirs ?? true) {\n      destinationPath.parent.mkdirSync();\n    }\n    cpSync(this.path, destinationPath.path, cpOptions);\n    return destinationPath;\n  }\n\n  renameSync(\n    destination: string | URL | Path,\n    options?: { createIntermediateDirs?: boolean },\n  ): PathSync {\n    const destinationPath = new PathSync(destination);\n    if (options?.createIntermediateDirs ?? true) {\n      destinationPath.parent.mkdirSync();\n    }\n    renameSync(this.path, destinationPath.path);\n    return destinationPath;\n  }\n\n  static makeTempDirSync(prefix?: string): PathSync {\n    return new PathSync(\n      mkdtempSync(new Path(tmpdir()).join(prefix ?? \"js-temp-\").toString()),\n    );\n  }\n\n  rmSync(options?: Parameters<typeof rmSync>[1]): void {\n    rmSync(this.path, options);\n  }\n\n  rmDirSync(): void {\n    rmdirSync(this.path);\n  }\n\n  rm_rfSync(options?: Parameters<typeof rmSync>[1]): void {\n    this.rmSync({ recursive: true, force: true, ...(options ?? {}) });\n  }\n\n  readSync: typeof readFileSyncType = (options) =>\n    // biome-ignore lint/suspicious/noExplicitAny: Needed to wrangle the types.\n    readFileSync(this.path, options) as any;\n\n  readTextSync(): string {\n    return readFileSync(this.path, \"utf-8\");\n  }\n\n  readJSONSync<T>(options?: { fallback?: T }): T {\n    try {\n      return JSON.parse(this.readTextSync());\n    } catch (e) {\n      if (\n        (e as { code?: string }).code === \"ENOENT\" &&\n        options &&\n        \"fallback\" in options\n      ) {\n        return options.fallback as T;\n      }\n      throw e;\n    }\n  }\n\n  appendFileSync(\n    data: Parameters<typeof appendFileSync>[1],\n    options?: Parameters<typeof appendFileSync>[2],\n  ): PathSync {\n    appendFileSync(this.path, data, options);\n    return this;\n  }\n\n  writeSync(\n    data: Parameters<typeof writeFileSync>[1],\n    options?: Parameters<typeof writeFileSync>[2],\n  ): PathSync {\n    this.parent.mkdirSync();\n    writeFileSync(this.path, data, options);\n    return this;\n  }\n\n  writeJSONSync<T>(\n    data: T,\n    replacer: Parameters<typeof JSON.stringify>[1] = null,\n    space: Parameters<typeof JSON.stringify>[2] = \"  \",\n  ): PathSync {\n    this.parent.mkdirSync();\n    this.writeSync(JSON.stringify(data, replacer, space));\n    return this;\n  }\n\n  // biome-ignore lint/suspicious/noExplicitAny: Type wrangling.\n  readDirSync: typeof readDirSyncType = (options: any) =>\n    // biome-ignore lint/suspicious/noExplicitAny: Needed to wrangle the types.\n    readdirSync(this.path, options) as any;\n\n  symlinkSync(\n    target: string | URL | Path,\n    type?: Parameters<typeof symlinkSync>[2],\n  ): PathSync {\n    const targetPath = new PathSync(target);\n    symlinkSync(\n      this.path,\n      targetPath.path,\n      type as Exclude<Parameters<typeof symlinkSync>[2], undefined>, // \uD83E\uDD37\n    );\n    return targetPath;\n  }\n\n  realpathSync(): PathSync {\n    return new PathSync(realpathSync(this.path));\n  }\n\n  statSync: typeof statSyncType = (options) =>\n    // biome-ignore lint/suspicious/noExplicitAny: Needed to wrangle the types.\n    statSync(this.path, options) as any;\n\n  lstatSync: typeof lstatSyncType = (options) =>\n    // biome-ignore lint/suspicious/noExplicitAny: Needed to wrangle the types.\n    lstatSync(this.path, options) as any;\n\n  chmodSync(mode: Parameters<typeof chmodSync>[1]): PathSync {\n    chmodSync(this.path, mode);\n    return this;\n  }\n\n  chmodXSync(): PathSync {\n    const { mode } = this.statSync();\n    this.chmodSync(\n      mode | constants.S_IXUSR | constants.S_IXGRP | constants.S_IXOTH,\n    );\n    return this;\n  }\n}\n"],
-  "mappings": "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",
+  "sourcesContent": ["import {\n  appendFileSync,\n  chmodSync,\n  cpSync,\n  lstatSync,\n  mkdirSync,\n  mkdtempSync,\n  readdirSync,\n  readFileSync,\n  realpathSync,\n  renameSync,\n  rmdirSync,\n  rmSync,\n  statSync,\n  symlinkSync,\n  writeFileSync,\n} from \"node:fs\";\nimport { constants } from \"node:fs/promises\";\nimport { tmpdir } from \"node:os\";\nimport { mustNotHaveTrailingSlash, Path } from \"../Path\";\nimport type {\n  lstatSyncType,\n  readDirSyncType,\n  readFileSyncType,\n  statSyncType,\n} from \"./modifiedNodeTypes\";\n\nconst DEFAULT_TEMP_PREFIX = \"js-temp-sync-\";\nconst DEFAULT_TEMP_FILE_NAME = \"file\";\n\nexport class PathSync extends Path {\n  static override fromString(s: string): PathSync {\n    return new PathSync(s);\n  }\n\n  static override resolve(...args: Parameters<typeof Path.resolve>): PathSync {\n    return new PathSync(Path.resolve(...args));\n  }\n\n  override resolve(...args: Parameters<Path[\"resolve\"]>): PathSync {\n    return new PathSync(super.resolve(...args));\n  }\n\n  override descendantRelativePath(\n    ...args: Parameters<Path[\"descendantRelativePath\"]>\n  ): PathSync | null {\n    const v = super.descendantRelativePath(...args);\n    if (v === null) {\n      return null;\n    }\n    return new PathSync(v);\n  }\n\n  override toggleTrailingSlash(\n    ...args: Parameters<Path[\"toggleTrailingSlash\"]>\n  ): PathSync {\n    return new PathSync(super.toggleTrailingSlash(...args));\n  }\n\n  override join(...args: Parameters<Path[\"join\"]>): PathSync {\n    return new PathSync(super.join(...args));\n  }\n\n  override asRelative(...args: Parameters<Path[\"asRelative\"]>): PathSync {\n    return new PathSync(super.asRelative(...args));\n  }\n\n  override asAbsolute(...args: Parameters<Path[\"asAbsolute\"]>): PathSync {\n    return new PathSync(super.asAbsolute(...args));\n  }\n\n  override asBare(...args: Parameters<Path[\"asBare\"]>): PathSync {\n    return new PathSync(super.asBare(...args));\n  }\n\n  override extendBasename(\n    ...args: Parameters<Path[\"extendBasename\"]>\n  ): PathSync {\n    return new PathSync(super.extendBasename(...args));\n  }\n\n  override get parent(): PathSync {\n    return new PathSync(super.parent);\n  }\n\n  override get dirname(): PathSync {\n    return new PathSync(super.dirname);\n  }\n\n  override get basename(): PathSync {\n    return new PathSync(super.basename);\n  }\n\n  static override get homedir(): PathSync {\n    return new PathSync(Path.homedir);\n  }\n\n  static override get cwd(): PathSync {\n    return new PathSync(Path.cwd);\n  }\n\n  override debugPrint(...args: Parameters<Path[\"debugPrint\"]>): PathSync {\n    return new PathSync(super.debugPrint(...args));\n  }\n\n  // TODO: find a neat way to dedup with the async version? // lint-sync-code-expect-error\n  existsSync(constraints?: { mustBe: \"file\" | \"directory\" }): boolean {\n    if (constraints?.mustBe === \"file\") {\n      mustNotHaveTrailingSlash(this);\n    }\n    let stats: ReturnType<typeof statSync>;\n    try {\n      stats = statSync(this.path);\n      // biome-ignore lint/suspicious/noExplicitAny: TypeScript limitation\n    } catch (e: any) {\n      if (e.code === \"ENOENT\") {\n        return false;\n      }\n      throw e;\n    }\n    if (!constraints?.mustBe) {\n      return true;\n    }\n    switch (constraints?.mustBe) {\n      case \"file\": {\n        if (stats.isFile()) {\n          return true;\n        }\n        throw new Error(`PathSync exists but is not a file: ${this.path}`);\n      }\n      case \"directory\": {\n        if (stats.isDirectory()) {\n          return true;\n        }\n        throw new Error(`PathSync exists but is not a directory: ${this.path}`);\n      }\n      default: {\n        throw new Error(\"Invalid path type constraint\");\n      }\n    }\n  }\n\n  existsAsFileSync(): boolean {\n    return this.existsSync({ mustBe: \"file\" });\n  }\n\n  existsAsDirSync(): boolean {\n    return this.existsSync({ mustBe: \"directory\" });\n  }\n\n  mkdirSync(options?: Parameters<typeof mkdirSync>[1]): PathSync {\n    const optionsObject = (() => {\n      if (typeof options === \"string\" || typeof options === \"number\") {\n        return { mode: options };\n      }\n      return options ?? {};\n    })();\n    mkdirSync(this.path, { recursive: true, ...optionsObject });\n    return this;\n  }\n\n  cpSync(\n    destination: string | URL | Path,\n    options?: Parameters<typeof cpSync>[2] & {\n      createIntermediateDirs?: boolean;\n    },\n  ): PathSync {\n    const { createIntermediateDirs, ...cpOptions } = options ?? {};\n    const destinationPath = new PathSync(destination);\n    if (createIntermediateDirs ?? true) {\n      destinationPath.parent.mkdirSync();\n    }\n    cpSync(this.path, destinationPath.path, cpOptions);\n    return destinationPath;\n  }\n\n  renameSync(\n    destination: string | URL | Path,\n    options?: { createIntermediateDirs?: boolean },\n  ): PathSync {\n    const destinationPath = new PathSync(destination);\n    if (options?.createIntermediateDirs ?? true) {\n      destinationPath.parent.mkdirSync();\n    }\n    renameSync(this.path, destinationPath.path);\n    return destinationPath;\n  }\n\n  static makeTempDirSync(prefix?: string): DisposablePathSync {\n    return new DisposablePathSync(\n      mkdtempSync(\n        new Path(tmpdir()).join(prefix ?? DEFAULT_TEMP_PREFIX).toString(),\n      ),\n    );\n  }\n\n  /**\n   * Return a path:\n   *\n   * - whose parent dir is a temp dir that *has* been created, but\n   * - which has itself not yet been created.\n   *\n   * Note that this path can actually also be used to create dir, but it is most\n   * convenient to get a path for a temporary file that can be written to, while\n   * having a disposal implementation that cleans everything up:\n   *\n   *     using tempFile = PathSync.tempFilePathSync({ basename: \"foo.txt\" });\n   *     tempFile.writeSync(\"hello world!\");\n   *     // \u2026\n   *\n   * Note that that the following are equivalent when *not* using `using`:\n   *\n   *     PathSync.tempFilePathSync({ basename: \"foo.txt\" });\n   *     PathSync.makeTempDirSync().join(\"file.txt\");\n   *\n   * However, it is recommended to use `using` to ensure cleanup.\n   */\n  static tempFilePathSync(options: {\n    tempDirPrefix?: string;\n    basename?: string | Path;\n  }): DisposablePathSync {\n    const tempDir = PathSync.makeTempDirSync(options?.tempDirPrefix);\n    return new DisposablePathSync(\n      tempDir.join(options?.basename ?? DEFAULT_TEMP_FILE_NAME),\n      { disposePathInstead: tempDir },\n    );\n  }\n\n  rmSync(options?: Parameters<typeof rmSync>[1]): void {\n    rmSync(this.path, options);\n  }\n\n  rmDirSync(): void {\n    rmdirSync(this.path);\n  }\n\n  rm_rfSync(options?: Parameters<typeof rmSync>[1]): void {\n    this.rmSync({ recursive: true, force: true, ...(options ?? {}) });\n  }\n\n  readSync: typeof readFileSyncType = (options) =>\n    // biome-ignore lint/suspicious/noExplicitAny: Needed to wrangle the types.\n    readFileSync(this.path, options) as any;\n\n  readTextSync(): string {\n    return readFileSync(this.path, \"utf-8\");\n  }\n\n  readJSONSync<T>(options?: { fallback?: T }): T {\n    try {\n      return JSON.parse(this.readTextSync());\n    } catch (e) {\n      if (\n        (e as { code?: string }).code === \"ENOENT\" &&\n        options &&\n        \"fallback\" in options\n      ) {\n        return options.fallback as T;\n      }\n      throw e;\n    }\n  }\n\n  appendFileSync(\n    data: Parameters<typeof appendFileSync>[1],\n    options?: Parameters<typeof appendFileSync>[2],\n  ): PathSync {\n    appendFileSync(this.path, data, options);\n    return this;\n  }\n\n  writeSync(\n    data: Parameters<typeof writeFileSync>[1],\n    options?: Parameters<typeof writeFileSync>[2],\n  ): PathSync {\n    this.parent.mkdirSync();\n    writeFileSync(this.path, data, options);\n    return this;\n  }\n\n  writeJSONSync<T>(\n    data: T,\n    replacer: Parameters<typeof JSON.stringify>[1] = null,\n    space: Parameters<typeof JSON.stringify>[2] = \"  \",\n  ): PathSync {\n    this.parent.mkdirSync();\n    this.writeSync(JSON.stringify(data, replacer, space));\n    return this;\n  }\n\n  // biome-ignore lint/suspicious/noExplicitAny: Type wrangling.\n  readDirSync: typeof readDirSyncType = (options: any) =>\n    // biome-ignore lint/suspicious/noExplicitAny: Needed to wrangle the types.\n    readdirSync(this.path, options) as any;\n\n  symlinkSync(\n    target: string | URL | Path,\n    type?: Parameters<typeof symlinkSync>[2],\n  ): PathSync {\n    const targetPath = new PathSync(target);\n    symlinkSync(\n      this.path,\n      targetPath.path,\n      type as Exclude<Parameters<typeof symlinkSync>[2], undefined>, // \uD83E\uDD37\n    );\n    return targetPath;\n  }\n\n  realpathSync(): PathSync {\n    return new PathSync(realpathSync(this.path));\n  }\n\n  statSync: typeof statSyncType = (options) =>\n    // biome-ignore lint/suspicious/noExplicitAny: Needed to wrangle the types.\n    statSync(this.path, options) as any;\n\n  lstatSync: typeof lstatSyncType = (options) =>\n    // biome-ignore lint/suspicious/noExplicitAny: Needed to wrangle the types.\n    lstatSync(this.path, options) as any;\n\n  chmodSync(mode: Parameters<typeof chmodSync>[1]): PathSync {\n    chmodSync(this.path, mode);\n    return this;\n  }\n\n  chmodXSync(): PathSync {\n    const { mode } = this.statSync();\n    this.chmodSync(\n      mode | constants.S_IXUSR | constants.S_IXGRP | constants.S_IXOTH,\n    );\n    return this;\n  }\n}\n\nexport class DisposablePathSync extends PathSync {\n  #options?: { disposePathInstead: PathSync };\n  constructor(\n    path: ConstructorParameters<typeof Path>[0],\n    options?: { disposePathInstead: Path | string },\n  ) {\n    super(path);\n    if (options) {\n      this.#options = {\n        disposePathInstead: new PathSync(options.disposePathInstead),\n      };\n    }\n  }\n\n  [Symbol.dispose]() {\n    (this.#options?.disposePathInstead ?? this).rm_rfSync();\n  }\n}\n"],
+  "mappings": "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",
   "names": []
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "path-class",
-  "version": "0.12.2",
+  "version": "0.13.0",
   "description": "A semantic `Path` class for `node` and `bun`. Inspired by `bun`'s [`file(…)`](https://bun.com/docs/runtime/file-io) API, but `node`-compatible.",
   "author": "Lucas Garron <code@garron.net>",
   "license": "MIT",
@@ -30,6 +30,7 @@
     "@cubing/dev-config": ">=0.8.1",
     "@types/bun": "^1.3.0",
     "bun-dx": ">=0.1.3",
+    "ergonomic-date": "^0.1.3",
     "esbuild": "^0.25.10",
     "printable-shell-command": "^4.0.4",
     "readme-cli-help": ">=0.4.9",

package/src/Path.test.ts

@@ -1,9 +1,10 @@
-import { expect, spyOn, test } from "bun:test";
+import { expect, jest, spyOn, test } from "bun:test";
+import assert from "node:assert";
+import { execSync } from "node:child_process";
 import { constants, readFile, realpath } from "node:fs/promises";
 import { join } from "node:path";
 import { chdir } from "node:process";
-import { PrintableShellCommand } from "printable-shell-command";
-import { Path, ResolutionPrefix, stringifyIfPath } from "./Path";
+import { Path, ResolutionPrefix } from "./Path";
 
 test.concurrent("constructor", async () => {
   expect(new Path("bare").path).toEqual("bare");
@@ -25,6 +26,8 @@ test.concurrent("constructor", async () => {
   expect(new Path("../").path).toEqual("../");
   expect(new Path(new URL("file:///root/")).path).toEqual("/root/");
   expect(new Path(new Path("foo")).path).toEqual("foo");
+
+  expect(new Path("./.foo").path).toEqual("./.foo");
 });
 
 test.concurrent(".fromString(…)", async () => {
@@ -83,6 +86,9 @@ test.concurrent("Path.resolve(…)", async () => {
   expect(Path.resolve("foo/lish", new Path("/bar/baz")).path).toEqual(
     "/bar/foo/lish",
   );
+  expect(Path.resolve("foo/lish", new Path("/bar/baz/")).path).toEqual(
+    "/bar/baz/foo/lish",
+  );
   expect(() => Path.resolve("foo/lish", new Path("bar/baz")).path).toThrow(
     /must be an absolute path/,
   );
@@ -95,6 +101,78 @@ test.concurrent("Path.resolve(…)", async () => {
   );
 });
 
+test.concurrent(".resolve(…)", async () => {
+  expect(new Path("/bar/baz").resolve("foo/lish").path).toEqual(
+    "/bar/foo/lish",
+  );
+  expect(new Path("/bar/baz/").resolve("foo/lish").path).toEqual(
+    "/bar/baz/foo/lish",
+  );
+  expect(() => new Path("bar/baz").resolve("foo/lish").path).toThrow(
+    /must be an absolute path/,
+  );
+});
+
+function mustNotBeNull<T>(t: T): Exclude<T, null> {
+  assert.notEqual(t, null);
+  // @ts-expect-error Cast
+  return t;
+}
+
+test.concurrent(".descendantRelativePath(…)", async () => {
+  expect(
+    mustNotBeNull(
+      new Path("/Users/lgarron/").descendantRelativePath(
+        "/Users/lgarron/Library",
+      ),
+    ).path,
+  ).toEqual("./Library");
+  expect(
+    mustNotBeNull(
+      new Path("/Users/lgarron/").descendantRelativePath(
+        "/Users/lgarron/Library/",
+      ),
+    ).path,
+  ).toEqual("./Library/");
+  expect(
+    () =>
+      mustNotBeNull(
+        new Path("/Users/lgarron").descendantRelativePath(
+          "/Users/lgarron/Library/",
+        ),
+      ).path,
+  ).toThrow("Ancestor must have a trailing slash.");
+  expect(
+    mustNotBeNull(
+      new Path("/Users/lgarron").descendantRelativePath(
+        "/Users/lgarron/Library/",
+        { requireTrailingSlashForAncestor: false },
+      ),
+    ).path,
+  ).toEqual("./Library/");
+  expect(
+    mustNotBeNull(
+      new Path("/Users/lgarron").descendantRelativePath(
+        "/Users/lgarron/Downloads/test.png",
+        { requireTrailingSlashForAncestor: false },
+      ),
+    ).path,
+  ).toEqual("./Downloads/test.png");
+  expect(
+    new Path("/Users/lgarron/").descendantRelativePath("/etc/hosts/"),
+  ).toBe(null);
+  expect(
+    new Path("/Users/lgarron/").descendantRelativePath("/Users/shared/"),
+  ).toBe(null);
+  expect(
+    mustNotBeNull(
+      new Path("/Users/lgarron/").descendantRelativePath(
+        "/Users/shared/../lgarron",
+      ),
+    ).path,
+  ).toBe(".");
+});
+
 test.concurrent(".isAbsolutePath()", async () => {
   expect(new Path("/foo/bar").isAbsolutePath()).toBe(true);
   expect(new Path("foo/bar").isAbsolutePath()).toBe(false);
@@ -132,6 +210,7 @@ test.concurrent(".toggleTrailingSlash(…)", async () => {
   expect(new Path(".").toggleTrailingSlash().path).toBe("./");
   expect(new Path("../").toggleTrailingSlash().path).toBe("..");
   expect(new Path("..").toggleTrailingSlash().path).toBe("../");
+  expect(new Path("./foo").toggleTrailingSlash().path).toEqual("./foo/");
 });
 
 test.concurrent(".blue", async () => {
@@ -151,6 +230,7 @@ test.concurrent("normalize", async () => {
 
 test.concurrent(".join(…)", async () => {
   expect(new Path("foo").join("bar").path).toEqual("foo/bar");
+  expect(new Path("./foo").join("bar").path).toEqual("./foo/bar");
   expect(new Path("foo/bar").join("bath", "kitchen/sink").path).toEqual(
     "foo/bar/bath/kitchen/sink",
   );
@@ -325,47 +405,49 @@ test.concurrent(".extname", async () => {
 });
 
 test.concurrent(".existsAsFile()", async () => {
-  const filePath = (await Path.makeTempDir()).join("file.txt");
-  expect(await filePath.exists()).toBe(false);
-  expect(await filePath.exists({ mustBe: "file" })).toBe(false);
-  expect(await filePath.exists({ mustBe: "directory" })).toBe(false);
-  expect(await filePath.existsAsFile()).toBe(false);
-  expect(() => filePath.join("./").existsAsFile()).toThrow(
+  await using file = await Path.tempFilePath({ basename: "file.txt" });
+  expect(await file.exists()).toBe(false);
+  expect(await file.exists({ mustBe: "file" })).toBe(false);
+  expect(await file.exists({ mustBe: "directory" })).toBe(false);
+  expect(await file.existsAsFile()).toBe(false);
+  expect(() => file.join("./").existsAsFile()).toThrow(
     "Path ends with a slash, which cannot be treated as a file.",
   );
-  await filePath.write("test");
-  expect(await filePath.exists()).toBe(true);
-  expect(await filePath.exists({ mustBe: "file" })).toBe(true);
-  expect(() => filePath.exists({ mustBe: "directory" })).toThrow(
+  await file.write("test");
+  expect(await file.exists()).toBe(true);
+  expect(await file.exists({ mustBe: "file" })).toBe(true);
+  expect(() => file.exists({ mustBe: "directory" })).toThrow(
     /Path exists but is not a directory/,
   );
-  expect(await filePath.existsAsFile()).toBe(true);
+  expect(await file.existsAsFile()).toBe(true);
 });
 
 test.concurrent(".existsAsDir()", async () => {
-  const filePath = await Path.makeTempDir();
-  expect(await filePath.exists()).toBe(true);
-  expect(() => filePath.exists({ mustBe: "file" })).toThrow(
+  await using tempDir = await Path.makeTempDir();
+  expect(await tempDir.exists()).toBe(true);
+  expect(() => tempDir.exists({ mustBe: "file" })).toThrow(
     /Path exists but is not a file/,
   );
-  expect(await filePath.exists({ mustBe: "directory" })).toBe(true);
-  expect(await filePath.existsAsDir()).toBe(true);
-  await filePath.rm_rf();
-  expect(await filePath.exists()).toBe(false);
-  expect(await filePath.exists({ mustBe: "file" })).toBe(false);
-  expect(await filePath.exists({ mustBe: "directory" })).toBe(false);
-  expect(await filePath.existsAsDir()).toBe(false);
+  expect(await tempDir.exists({ mustBe: "directory" })).toBe(true);
+  expect(await tempDir.existsAsDir()).toBe(true);
+  await tempDir.rm_rf();
+  expect(await tempDir.exists()).toBe(false);
+  expect(await tempDir.exists({ mustBe: "file" })).toBe(false);
+  expect(await tempDir.exists({ mustBe: "directory" })).toBe(false);
+  expect(await tempDir.existsAsDir()).toBe(false);
 });
 
 test.concurrent(".mkdir(…) (un-nested)", async () => {
-  const dir = (await Path.makeTempDir()).join("mkdir-test");
+  await using tempDir = await Path.makeTempDir();
+  const dir = tempDir.join("mkdir-test");
   expect(await dir.exists()).toBe(false);
   await dir.mkdir();
   expect(await dir.exists()).toBe(true);
 });
 
 test.concurrent(".mkdir(…) (nested)", async () => {
-  const dir = (await Path.makeTempDir()).join("mkdir-test/nested");
+  await using tempDir = await Path.makeTempDir();
+  const dir = tempDir.join("mkdir-test/nested");
   expect(await dir.exists()).toBe(false);
   expect(() => dir.mkdir({ recursive: false })).toThrow("no such file");
   await dir.mkdir();
@@ -373,7 +455,7 @@ test.concurrent(".mkdir(…) (nested)", async () => {
 });
 
 test.concurrent(".cp(…)", async () => {
-  const parentDir = await Path.makeTempDir();
+  await using parentDir = await Path.makeTempDir();
   const file1 = parentDir.join("file1.txt");
   const file2 = parentDir.join("file2.txt");
   const file3 = parentDir.join("nonexistent/dirs/file3.txt");
@@ -398,7 +480,7 @@ test.concurrent(".cp(…)", async () => {
 });
 
 test.concurrent(".rename(…)", async () => {
-  const parentDir = await Path.makeTempDir();
+  await using parentDir = await Path.makeTempDir();
   const file1 = parentDir.join("file1.txt");
   const file2 = parentDir.join("file2.txt");
   const file3 = parentDir.join("nonexistent/dirs/file3.txt");
@@ -444,41 +526,41 @@ test.concurrent(".makeTempDir(…)", async () => {
 });
 
 test.concurrent(".rm(…) (file)", async () => {
-  const file = (await Path.makeTempDir()).join("file.txt");
-  await file.write("");
-  expect(await file.existsAsFile()).toBe(true);
-  await file.rm();
-  expect(await file.existsAsFile()).toBe(false);
-  expect(await file.parent.existsAsDir()).toBe(true);
-  expect(async () => file.rm()).toThrowError(/ENOENT/);
+  await using filePath = await Path.tempFilePath({ basename: "file.txt" });
+  await filePath.write("");
+  expect(await filePath.existsAsFile()).toBe(true);
+  await filePath.rm();
+  expect(await filePath.existsAsFile()).toBe(false);
+  expect(await filePath.parent.existsAsDir()).toBe(true);
+  expect(async () => filePath.rm()).toThrow(/^ENOENT/);
 });
 
 test.concurrent(".rm(…) (folder)", async () => {
-  const tempDir = await Path.makeTempDir();
+  await using tempDir = await Path.makeTempDir();
   const file = tempDir.join("file.txt");
   await file.write("");
   expect(await tempDir.existsAsDir()).toBe(true);
-  expect(async () => tempDir.rm()).toThrowError(/EACCES|EFAULT/);
+  expect(async () => tempDir.rm()).toThrow(/^(EACCES|EFAULT)/);
   await file.rm();
   await tempDir.rm({ recursive: true });
   expect(await tempDir.existsAsDir()).toBe(false);
-  expect(async () => tempDir.rm()).toThrowError(/ENOENT/);
+  expect(async () => tempDir.rm()).toThrow(/^ENOENT/);
 });
 
 test.concurrent(".rmDir(…)", async () => {
-  const tempDir = await Path.makeTempDir();
+  await using tempDir = await Path.makeTempDir();
   const file = tempDir.join("file.txt");
   await file.write("");
   expect(await tempDir.existsAsDir()).toBe(true);
-  expect(async () => tempDir.rmDir()).toThrowError(/ENOTEMPTY/);
+  expect(async () => tempDir.rmDir()).toThrow(/^ENOTEMPTY/);
   await file.rm();
   await tempDir.rmDir();
   expect(await tempDir.existsAsDir()).toBe(false);
-  expect(async () => tempDir.rmDir()).toThrowError(/ENOENT/);
+  expect(async () => tempDir.rmDir()).toThrow(/^ENOENT/);
 });
 
 test.concurrent(".rm_rf(…) (file)", async () => {
-  const file = (await Path.makeTempDir()).join("file.txt");
+  await using file = await Path.tempFilePath({ basename: "file.txt" });
   await file.write("");
   expect(await file.existsAsFile()).toBe(true);
   await file.rm_rf();
@@ -489,7 +571,7 @@ test.concurrent(".rm_rf(…) (file)", async () => {
 });
 
 test.concurrent(".rm_rf(…) (folder)", async () => {
-  const tempDir = await Path.makeTempDir();
+  await using tempDir = await Path.makeTempDir();
   await tempDir.join("file.txt").write("");
   expect(tempDir.path).toContain("/js-temp-");
   expect(await tempDir.exists()).toBe(true);
@@ -500,7 +582,7 @@ test.concurrent(".rm_rf(…) (folder)", async () => {
 });
 
 test.concurrent(".readText()", async () => {
-  const file = (await Path.makeTempDir()).join("file.txt");
+  await using file = await Path.tempFilePath({ basename: "file.txt" });
   await file.write("hi");
   await file.write("bye");
 
@@ -509,14 +591,14 @@ test.concurrent(".readText()", async () => {
 });
 
 test.concurrent(".readLines()", async () => {
-  const file = (await Path.makeTempDir()).join("file.txt");
+  await using file = await Path.tempFilePath({ basename: "file.txt" });
   await file.write("hi\nbye\n");
 
   expect(await Array.fromAsync(file.readLines())).toEqual(["hi", "bye"]);
 });
 
 test.concurrent(".readJSON()", async () => {
-  const file = (await Path.makeTempDir()).join("file.json");
+  await using file = await Path.tempFilePath({ basename: "file.json" });
   await file.write(JSON.stringify({ foo: "bar" }));
 
   expect(await file.readJSON()).toEqual<Record<string, string>>({ foo: "bar" });
@@ -527,7 +609,7 @@ test.concurrent(".readJSON()", async () => {
 });
 
 test.concurrent(".readJSON(…) with fallback", async () => {
-  const tempDir = await Path.makeTempDir();
+  await using tempDir = await Path.makeTempDir();
   const file = tempDir.join("file.json");
   const json: { foo?: number } = await file.readJSON({ fallback: { foo: 4 } });
   expect(json).toEqual({ foo: 4 });
@@ -539,13 +621,11 @@ test.concurrent(".readJSON(…) with fallback", async () => {
   });
   expect(json2).toEqual({ foo: 6 });
 
-  expect(() => tempDir.readJSON({ fallback: { foo: 4 } })).toThrowError(
-    /^EISDIR/,
-  );
+  expect(() => tempDir.readJSON({ fallback: { foo: 4 } })).toThrow(/^EISDIR/);
 });
 
 test.concurrent(".write(…)", async () => {
-  const tempDir = await Path.makeTempDir();
+  await using tempDir = await Path.makeTempDir();
   const file = tempDir.join("file.json");
   expect(await file.write("foo")).toBe(file);
 
@@ -561,14 +641,14 @@ test.concurrent(".write(…)", async () => {
 });
 
 test.concurrent(".writeJSON(…)", async () => {
-  const file = (await Path.makeTempDir()).join("file.json");
+  await using file = await Path.tempFilePath({ basename: "file.json" });
   expect(await file.writeJSON({ foo: "bar" })).toBe(file);
 
   expect(await file.readJSON()).toEqual<Record<string, string>>({ foo: "bar" });
 });
 
 test.concurrent(".appendFile(…)", async () => {
-  const file = (await Path.makeTempDir()).join("file.txt");
+  await using file = await Path.tempFilePath({ basename: "file.txt" });
   await file.appendFile("test\n");
   expect(await file.readText()).toEqual("test\n");
   await file.appendFile("more\n");
@@ -576,7 +656,7 @@ test.concurrent(".appendFile(…)", async () => {
 });
 
 test.concurrent(".readDir(…)", async () => {
-  const dir = await Path.makeTempDir();
+  await using dir = await Path.makeTempDir();
   await dir.join("file.txt").write("hello");
   await dir.join("dir/file.json").write("hello");
 
@@ -590,19 +670,19 @@ test.concurrent(".readDir(…)", async () => {
 });
 
 test.concurrent(".symlink(…)", async () => {
-  const tempDir = await Path.makeTempDir();
+  await using tempDir = await Path.makeTempDir();
   const source = tempDir.join("foo.txt");
   const target = tempDir.join("bar.txt");
   await source.symlink(target);
   expect(await target.existsAsFile()).toBe(false);
-  expect(() => target.readText()).toThrow(/ENOENT/);
+  expect(() => target.readText()).toThrow(/^ENOENT/);
   await source.write("hello");
   expect(await target.existsAsFile()).toBe(true);
   expect(await target.readText()).toEqual("hello");
 });
 
 test.concurrent(".realpath(…)", async () => {
-  const tempDir = await Path.makeTempDir();
+  await using tempDir = await Path.makeTempDir();
   const source = tempDir.join("foo.txt");
   await source.write("hello world!");
   const target = tempDir.join("bar.txt");
@@ -613,7 +693,7 @@ test.concurrent(".realpath(…)", async () => {
 });
 
 test.concurrent(".stat(…)", async () => {
-  const file = (await Path.makeTempDir()).join("foo.txt");
+  await using file = await Path.tempFilePath({ basename: "foo.txt" });
   await file.write("hello");
 
   expect((await file.stat()).size).toEqual(5);
@@ -622,7 +702,7 @@ test.concurrent(".stat(…)", async () => {
 });
 
 test.concurrent(".lstat(…)", async () => {
-  const tempDir = await Path.makeTempDir();
+  await using tempDir = await Path.makeTempDir();
   const source = tempDir.join("foo.txt");
   const target = tempDir.join("bar.txt");
   await source.symlink(target);
@@ -635,45 +715,37 @@ test.concurrent(".lstat(…)", async () => {
 });
 
 test.concurrent(".chmod(…)", async () => {
-  const binPath = (await Path.makeTempDir()).join("nonexistent.bin");
-  expect(() => new PrintableShellCommand(binPath, []).text()).toThrow(
-    /ENOENT|Premature close/,
+  await using binPath = await Path.tempFilePath({
+    basename: "bin.bash",
+  });
+  expect(() => execSync(binPath.path)).toThrow(
+    /No such file or directory|not found/,
   );
-  await binPath.write(`#!/usr/bin/env bash
+  await binPath.write(`#!/usr/bin/env -S bun run --
 
-echo hi`);
-  // TODO: why doesn't this work here instead (but works in `printable-shell-comand`)?
-  //   await binPath.write(`#!/usr/bin/env -S bun run --
-
-  // console.log("hi");`);
-  expect(() => new PrintableShellCommand(binPath, []).text()).toThrow(
-    /EACCES|Premature close/,
-  );
+  console.log("hi");`);
+  expect(() => execSync(binPath.path)).toThrow(/Permission denied/);
   await binPath.chmod(0o755);
-  expect(await new PrintableShellCommand(binPath, []).text()).toEqual("hi\n");
+  expect(execSync(binPath.path, { encoding: "utf-8" })).toEqual("hi\n");
 });
 
 test.concurrent(".chmodX(…)", async () => {
-  const binPath = (await Path.makeTempDir()).join("nonexistent.bin");
-  expect(() => new PrintableShellCommand(binPath, []).text()).toThrow(
-    /ENOENT|Premature close/,
+  await using binPath = await Path.tempFilePath({
+    basename: "bin.bash",
+  });
+  expect(() => execSync(binPath.path)).toThrow(
+    /No such file or directory|not found/,
   );
-  await binPath.write(`#!/usr/bin/env bash
+  await binPath.write(`#!/usr/bin/env -S bun run --
 
-echo hi`);
-  // TODO: why doesn't this work here instead (but works in `printable-shell-comand`)?
-  //   await binPath.write(`#!/usr/bin/env -S bun run --
-
-  // console.log("hi");`);
-  expect(() => new PrintableShellCommand(binPath, []).text()).toThrow(
-    /EACCES|Premature close/,
-  );
+  console.log("hi");`);
+  expect(() => execSync(binPath.path)).toThrow(/Permission denied/);
   expect((await binPath.stat()).mode & constants.S_IWUSR).toBeTruthy();
   await binPath.chmod(0o444);
   expect((await binPath.stat()).mode & constants.S_IWUSR).toBeFalsy();
   expect((await binPath.stat()).mode & constants.S_IXUSR).toBeFalsy();
   await binPath.chmodX();
-  expect(await new PrintableShellCommand(binPath, []).text()).toEqual("hi\n");
+  expect(execSync(binPath.path, { encoding: "utf-8" })).toEqual("hi\n");
   expect((await binPath.stat()).mode & constants.S_IWUSR).toBeFalsy();
   expect((await binPath.stat()).mode & constants.S_IXUSR).toBeTruthy();
 });
@@ -682,11 +754,14 @@ test.concurrent(".homedir", async () => {
   expect(Path.homedir.path).toEqual("/mock/home/dir");
 });
 
-test.concurrent(".cwd", async () => {
+// This is serial because it can break binary execution tests elsewhere.
+test.serial(".cwd", async () => {
+  const originalCwd = Path.cwd;
   expect(Path.cwd.basename.path).toEqual("path-class");
-  const tempDir = await Path.makeTempDir();
+  await using tempDir = await Path.makeTempDir();
   chdir(tempDir.path);
   expect(await realpath(Path.cwd.path)).toEqual(await realpath(tempDir.path));
+  chdir(originalCwd.path);
 });
 
 test.concurrent(".xdg", async () => {
@@ -700,20 +775,12 @@ test.concurrent(".xdg", async () => {
   );
 });
 
-const spy = spyOn(console, "log");
-
-test(".debugPrint(…)", async () => {
-  spy.mockReset();
+test.concurrent(".debugPrint(…)", async () => {
+  const spy = spyOn(console, "log");
   Path.homedir.debugPrint("Here is a test log of the mock home directory:");
   expect(spy.mock.calls).toEqual([
     ["Here is a test log of the mock home directory:"],
     ["/mock/home/dir"],
   ]);
-});
-
-test(".stringifyIfPath(…)", async () => {
-  spy.mockReset();
-  expect(stringifyIfPath(Path.homedir)).toBe("/mock/home/dir");
-  expect(stringifyIfPath("/mock/home/dir")).toBe("/mock/home/dir");
-  expect(stringifyIfPath(4)).toBe(4);
+  jest.restoreAllMocks();
 });