path-class 0.10.13 → 0.11.0

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
-  "sources": ["../../../../src/sync/index.ts", "../../../../src/sync/static.ts"],
-  "sourcesContent": ["import {\n  appendFileSync,\n  cpSync,\n  lstatSync,\n  mkdirSync,\n  readdirSync,\n  readFileSync,\n  realpathSync,\n  renameSync,\n  rmdirSync,\n  rmSync,\n  statSync,\n  symlinkSync,\n  writeFileSync,\n} from \"node:fs\";\nimport { mustNotHaveTrailingSlash, Path } from \"../Path\";\nimport \"./static\";\nimport type {\n  lstatSyncType,\n  readDirSyncType,\n  readFileSyncType,\n  statSyncType,\n} from \"./modifiedNodeTypes\";\n\n// Note that (non-static) functions in this file are defined using `function(\u2026)\n// { \u2026 }` rather than arrow functions, specifically because we want `this` to\n// operate on the `Path` instance.\n\ndeclare module \"../Path\" {\n  interface Path {\n    existsSync(constraints?: { mustBe: \"file\" | \"directory\" }): boolean;\n    existsAsFileSync(): boolean;\n    existsAsDirSync(): boolean;\n\n    mkdirSync(options?: Parameters<typeof mkdirSync>[1]): Path;\n    cpSync(\n      destination: string | URL | Path,\n      options?: Parameters<typeof cpSync>[2],\n    ): Path;\n    renameSync(destination: string | URL | Path): void;\n\n    rmSync(options?: Parameters<typeof rmSync>[1]): void;\n    rmDirSync(options?: Parameters<typeof rmdirSync>[1]): void;\n    rm_rfSync(options?: Parameters<typeof rmSync>[1]): void;\n\n    readSync: typeof readFileSyncType;\n    readTextSync(): string;\n    readJSONSync<T>(options?: { fallback?: T }): T;\n\n    appendFileSync(\n      data: Parameters<typeof appendFileSync>[1],\n      options?: Parameters<typeof appendFileSync>[2],\n    ): Path;\n\n    writeSync(\n      data: Parameters<typeof writeFileSync>[1],\n      options?: Parameters<typeof writeFileSync>[2] | undefined,\n    ): Path;\n    writeJSONSync<T>(\n      data: T,\n      replacer?: Parameters<typeof JSON.stringify>[1],\n      space?: Parameters<typeof JSON.stringify>[2],\n    ): Path;\n\n    readDirSync: typeof readDirSyncType;\n\n    /** Returns the destination path. */\n    symlinkSync(\n      target: string | URL | Path,\n      type?: Parameters<typeof symlinkSync>[2],\n    ): Path;\n    realpathSync(): Path;\n\n    statSync: typeof statSyncType;\n    lstatSync: typeof lstatSyncType;\n  }\n}\n\n// TODO: find a neat way to dedup with the async version? // lint-sync-code-expect-error\nPath.prototype.existsSync = function (constraints?: {\n  mustBe: \"file\" | \"directory\";\n}): 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(`Path exists but is not a file: ${this.path}`);\n    }\n    case \"directory\": {\n      if (stats.isDirectory()) {\n        return true;\n      }\n      throw new Error(`Path exists but is not a directory: ${this.path}`);\n    }\n    default: {\n      throw new Error(\"Invalid path type constraint\");\n    }\n  }\n};\n\nPath.prototype.existsAsFileSync = function (): boolean {\n  return this.existsSync({ mustBe: \"file\" });\n};\n\nPath.prototype.existsAsDirSync = function (): boolean {\n  return this.existsSync({ mustBe: \"directory\" });\n};\n\nPath.prototype.mkdirSync = function (\n  options?: Parameters<typeof mkdirSync>[1],\n): Path {\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\nPath.prototype.cpSync = function (\n  destination: string | URL | Path,\n  options?: Parameters<typeof cpSync>[2],\n): Path {\n  cpSync(this.path, new Path(destination).path, options);\n  return new Path(destination);\n};\n\nPath.prototype.renameSync = function (destination: string | URL | Path): void {\n  renameSync(this.path, new Path(destination).path);\n};\n\nPath.prototype.rmSync = function (\n  options?: Parameters<typeof rmSync>[1],\n): void {\n  rmSync(this.path, options);\n};\n\nPath.prototype.rmDirSync = function (): void {\n  rmdirSync(this.path);\n};\n\nPath.prototype.rm_rfSync = function (\n  options?: Parameters<typeof rmSync>[1],\n): void {\n  this.rmSync({ recursive: true, force: true, ...(options ?? {}) });\n};\n\nPath.prototype.readSync = function () {\n  /** @ts-expect-error ts(2683) */\n  return readFileSync(this.path);\n} as typeof readFileSyncType;\n\nPath.prototype.readTextSync = function (): string {\n  return readFileSync(this.path, \"utf-8\");\n};\n\nPath.prototype.readJSONSync = function <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\nPath.prototype.appendFileSync = function (\n  data: Parameters<typeof appendFileSync>[1],\n  options?: Parameters<typeof appendFileSync>[2],\n): Path {\n  appendFileSync(this.path, data, options);\n  return this;\n};\n\nPath.prototype.writeSync = function (\n  data: Parameters<typeof writeFileSync>[1],\n  options?: Parameters<typeof writeFileSync>[2],\n): Path {\n  this.parent.mkdirSync();\n  writeFileSync(this.path, data, options);\n  return this;\n};\n\nPath.prototype.writeJSONSync = function <T>(\n  data: T,\n  replacer: Parameters<typeof JSON.stringify>[1] = null,\n  space: Parameters<typeof JSON.stringify>[2] = \"  \",\n): Path {\n  this.parent.mkdirSync();\n  this.writeSync(JSON.stringify(data, replacer, space));\n  return this;\n};\n\n/** @ts-expect-error ts(2322): Wrangle types */\nPath.prototype.readDirSync = function (options) {\n  // biome-ignore lint/suspicious/noExplicitAny: Needed to wrangle the types.\n  return readdirSync(this.path, options as any);\n};\n\nPath.prototype.symlinkSync = function (\n  target: string | URL | Path,\n  type?: Parameters<typeof symlinkSync>[2],\n): Path {\n  const targetPath = new Path(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\nPath.prototype.realpathSync = function (): Path {\n  return new Path(realpathSync(this.path));\n};\n\n/** @ts-expect-error ts(2322): Wrangle types */\nPath.prototype.statSync = function (\n  options?: Parameters<typeof statSync>[1],\n): ReturnType<typeof statSync> {\n  return statSync(this.path, options);\n};\n\n/** @ts-expect-error ts(2322): Wrangle types */\nPath.prototype.lstatSync = function (\n  options?: Parameters<typeof lstatSync>[1],\n): ReturnType<typeof lstatSync> {\n  return lstatSync(this.path, options);\n};\n", "import { mkdtempSync } from \"node:fs\";\nimport { tmpdir } from \"node:os\";\nimport { Path } from \"../Path\";\n\ndeclare module \"../Path\" {\n  namespace Path {\n    export function makeTempDirSync(prefix?: string): Path;\n  }\n}\n\nPath.makeTempDirSync = (prefix?: string): Path =>\n  new Path(\n    mkdtempSync(new Path(tmpdir()).join(prefix ?? \"js-temp-\").toString()),\n  );\n"],
-  "mappings": "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",
+  "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  ): PathSync {\n    cpSync(this.path, new Path(destination).path, options);\n    return new PathSync(destination);\n  }\n\n  renameSync(destination: string | URL | Path): void {\n    renameSync(this.path, new Path(destination).path);\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 |\n        constants.S_IRWXU |\n        constants.S_IXUSR |\n        constants.S_IXGRP |\n        constants.S_IXOTH,\n    );\n    return this;\n  }\n}\n"],
+  "mappings": "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",
   "names": []
 }

package/dist/lib/path-class/sync/modifiedNodeTypes.d.ts

@@ -1,4 +1,5 @@
-import type { BigIntStats, Dirent, ObjectEncodingOptions, StatSyncOptions, Stats } from "node:fs";
+import type { Abortable } from "node:events";
+import type { BigIntStats, Dirent, Mode, ObjectEncodingOptions, StatSyncOptions, Stats } from "node:fs";
 export declare function readFileSyncType(options?: {
     encoding?: null | undefined;
     flag?: string | undefined;
@@ -10,6 +11,11 @@ export declare function readFileSyncType(options: {
 export declare function readFileSyncType(options?: (ObjectEncodingOptions & {
     flag?: string | undefined;
 }) | BufferEncoding | null): string | NonSharedBuffer;
+export type WriteFileOptions = (ObjectEncodingOptions & Abortable & {
+    mode?: Mode | undefined;
+    flag?: string | undefined;
+    flush?: boolean | undefined;
+}) | BufferEncoding | null;
 export declare function readDirSyncType(options?: {
     encoding: BufferEncoding | null;
     withFileTypes?: false | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "path-class",
-  "version": "0.10.13",
+  "version": "0.11.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",
@@ -22,20 +22,19 @@
     }
   },
   "dependencies": {
-    "xdg-basedir": "^5.1.0"
+    "xdg-basedir": "^5.1.0",
+    "@types/node": ">=24.7.1"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.2.5",
-    "@cubing/dev-config": "^0.3.6",
+    "@cubing/dev-config": ">=0.8.1",
     "@types/bun": "^1.3.0",
+    "bun-dx": ">=0.1.3",
     "esbuild": "^0.25.10",
-    "printable-shell-command": "^2.6.3",
+    "printable-shell-command": "^4.0.4",
     "readme-cli-help": ">=0.4.9",
     "typescript": "^5.9.3"
   },
-  "peerDependencies": {
-    "@types/node": ">=24.7.1"
-  },
   "files": [
     "./dist/",
     "./src"

package/src/Path.test.ts

@@ -2,6 +2,7 @@ import { expect, spyOn, test } from "bun:test";
 import { 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";
 
 test("constructor", async () => {
@@ -597,6 +598,44 @@ test(".lstat(…)", async () => {
   expect(await target.readText()).toEqual("hello");
 });
 
+test(".chmod(…)", async () => {
+  const binPath = (await Path.makeTempDir()).join("nonexistent.bin");
+  expect(() => new PrintableShellCommand(binPath, []).text()).toThrow(
+    /ENOENT|Premature close/,
+  );
+  await binPath.write(`#!/usr/bin/env bash
+
+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/,
+  );
+  await binPath.chmod(0o755);
+  expect(await new PrintableShellCommand(binPath, []).text()).toEqual("hi\n");
+});
+
+test(".chmodX(…)", async () => {
+  const binPath = (await Path.makeTempDir()).join("nonexistent.bin");
+  expect(() => new PrintableShellCommand(binPath, []).text()).toThrow(
+    /ENOENT|Premature close/,
+  );
+  await binPath.write(`#!/usr/bin/env bash
+
+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/,
+  );
+  await binPath.chmodX();
+  expect(await new PrintableShellCommand(binPath, []).text()).toEqual("hi\n");
+});
+
 test(".homedir", async () => {
   expect(Path.homedir.path).toEqual("/mock/home/dir");
 });

package/src/Path.ts

@@ -1,5 +1,7 @@
 import {
   appendFile,
+  chmod,
+  constants,
   cp,
   lstat,
   mkdir,
@@ -57,7 +59,7 @@ export enum ResolutionPrefix {
   Bare = "bare",
 }
 
-function resolutionPrefix(pathString: string): ResolutionPrefix {
+export function resolutionPrefix(pathString: string): ResolutionPrefix {
   if (pathString.startsWith("/")) {
     return ResolutionPrefix.Absolute;
   } else if (pathString.startsWith("./")) {
@@ -607,6 +609,26 @@ export class Path {
     // biome-ignore lint/suspicious/noExplicitAny: Needed to wrangle the types.
     lstat(this.#path, ...options) as any;
 
+  async chmod(mode: Parameters<typeof chmod>[1]): Promise<Path> {
+    await chmod(this.#path, mode);
+    return this;
+  }
+
+  /**
+   * Add the executable bit (for everyone) to the given path without modifying other bits (`chmod +x`).
+   */
+  async chmodX(): Promise<Path> {
+    const { mode } = await this.stat();
+    await this.chmod(
+      mode |
+        constants.S_IRWXU |
+        constants.S_IXUSR |
+        constants.S_IXGRP |
+        constants.S_IXOTH,
+    );
+    return this;
+  }
+
   static get homedir(): Path {
     return new Path(homedir());
   }

package/src/sync/{sync.test.ts → PathSync.test.ts}

@@ -1,11 +1,13 @@
 import { expect, test } from "bun:test";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
-import { Path } from "../Path";
-import "./index";
+import "./PathSync";
+import { PrintableShellCommand } from "printable-shell-command";
+
+import { PathSync } from "./PathSync";
 
 test(".existsAsFileSync()", () => {
-  const filePath = Path.makeTempDirSync().join("file.txt");
+  const filePath = PathSync.makeTempDirSync().join("file.txt");
   expect(filePath.existsSync()).toBe(false);
   expect(filePath.existsSync({ mustBe: "file" })).toBe(false);
   expect(filePath.existsSync({ mustBe: "directory" })).toBe(false);
@@ -17,16 +19,16 @@ test(".existsAsFileSync()", () => {
   expect(filePath.existsSync()).toBe(true);
   expect(filePath.existsSync({ mustBe: "file" })).toBe(true);
   expect(() => filePath.existsSync({ mustBe: "directory" })).toThrow(
-    /Path exists but is not a directory/,
+    /PathSync exists but is not a directory/,
   );
   expect(filePath.existsAsFileSync()).toBe(true);
 });
 
 test(".existsAsDir()", () => {
-  const filePath = Path.makeTempDirSync();
+  const filePath = PathSync.makeTempDirSync();
   expect(filePath.existsSync()).toBe(true);
   expect(() => filePath.existsSync({ mustBe: "file" })).toThrow(
-    /Path exists but is not a file/,
+    /PathSync exists but is not a file/,
   );
   expect(filePath.existsSync({ mustBe: "directory" })).toBe(true);
   expect(filePath.existsAsDirSync()).toBe(true);
@@ -38,14 +40,14 @@ test(".existsAsDir()", () => {
 });
 
 test(".mkdirSync(…) (un-nested)", () => {
-  const dir = Path.makeTempDirSync().join("mkdir-test");
+  const dir = PathSync.makeTempDirSync().join("mkdir-test");
   expect(dir.existsSync()).toBe(false);
   dir.mkdirSync();
   expect(dir.existsSync()).toBe(true);
 });
 
 test(".mkdirSync(…) (nested)", () => {
-  const dir = Path.makeTempDirSync().join("mkdir-test/nested");
+  const dir = PathSync.makeTempDirSync().join("mkdir-test/nested");
   expect(dir.existsSync()).toBe(false);
   expect(() => dir.mkdirSync({ recursive: false })).toThrow("no such file");
   dir.mkdirSync();
@@ -53,7 +55,7 @@ test(".mkdirSync(…) (nested)", () => {
 });
 
 test(".cpSync(…)", () => {
-  const parentDir = Path.makeTempDirSync();
+  const parentDir = PathSync.makeTempDirSync();
   const file1 = parentDir.join("file1.txt");
   const file2 = parentDir.join("file2.txt");
 
@@ -67,7 +69,7 @@ test(".cpSync(…)", () => {
 });
 
 test(".renameSync(…)", () => {
-  const parentDir = Path.makeTempDirSync();
+  const parentDir = PathSync.makeTempDirSync();
   const file1 = parentDir.join("file1.txt");
   const file2 = parentDir.join("file2.txt");
 
@@ -81,18 +83,18 @@ test(".renameSync(…)", () => {
 });
 
 test(".makeTempDirSync(…)", () => {
-  const tempDir = Path.makeTempDirSync();
+  const tempDir = PathSync.makeTempDirSync();
   expect(tempDir.path).toContain("/js-temp-");
   expect(tempDir.basename.path).toStartWith("js-temp-");
   expect(tempDir.existsAsDirSync()).toBe(true);
 
-  const tempDir2 = Path.makeTempDirSync("foo");
+  const tempDir2 = PathSync.makeTempDirSync("foo");
   expect(tempDir2.path).not.toContain("/js-temp-");
   expect(tempDir2.basename.path).toStartWith("foo");
 });
 
 test(".rmSync(…) (file)", () => {
-  const file = Path.makeTempDirSync().join("file.txt");
+  const file = PathSync.makeTempDirSync().join("file.txt");
   file.writeSync("");
   expect(file.existsAsFileSync()).toBe(true);
   file.rmSync();
@@ -102,7 +104,7 @@ test(".rmSync(…) (file)", () => {
 });
 
 test(".rmSync(…) (folder)", () => {
-  const tempDir = Path.makeTempDirSync();
+  const tempDir = PathSync.makeTempDirSync();
   const file = tempDir.join("file.txt");
   file.writeSync("");
   expect(tempDir.existsAsDirSync()).toBe(true);
@@ -114,7 +116,7 @@ test(".rmSync(…) (folder)", () => {
 });
 
 test(".rmDirSync(…) (folder)", () => {
-  const tempDir = Path.makeTempDirSync();
+  const tempDir = PathSync.makeTempDirSync();
   const file = tempDir.join("file.txt");
   file.writeSync("");
   expect(tempDir.existsAsDirSync()).toBe(true);
@@ -126,7 +128,7 @@ test(".rmDirSync(…) (folder)", () => {
 });
 
 test(".rm_rfSync(…) (file)", () => {
-  const file = Path.makeTempDirSync().join("file.txt");
+  const file = PathSync.makeTempDirSync().join("file.txt");
   file.writeSync("");
   expect(file.existsAsFileSync()).toBe(true);
   file.rm_rfSync();
@@ -137,7 +139,7 @@ test(".rm_rfSync(…) (file)", () => {
 });
 
 test(".rm_rfSync(…) (folder)", () => {
-  const tempDir = Path.makeTempDirSync();
+  const tempDir = PathSync.makeTempDirSync();
   tempDir.join("file.txt").writeSync("");
   expect(tempDir.path).toContain("/js-temp-");
   expect(tempDir.existsSync()).toBe(true);
@@ -148,7 +150,7 @@ test(".rm_rfSync(…) (folder)", () => {
 });
 
 test(".readTextSync()", () => {
-  const file = Path.makeTempDirSync().join("file.txt");
+  const file = PathSync.makeTempDirSync().join("file.txt");
   file.writeSync("hi");
   file.writeSync("bye");
 
@@ -157,7 +159,7 @@ test(".readTextSync()", () => {
 });
 
 test(".readJSONSync()", () => {
-  const file = Path.makeTempDirSync().join("file.json");
+  const file = PathSync.makeTempDirSync().join("file.json");
   file.writeSync(JSON.stringify({ foo: "bar" }));
 
   expect(file.readJSONSync()).toEqual<Record<string, string>>({ foo: "bar" });
@@ -168,7 +170,7 @@ test(".readJSONSync()", () => {
 });
 
 test(".readJSONSync(…) with fallback", () => {
-  const tempDir = Path.makeTempDirSync();
+  const tempDir = PathSync.makeTempDirSync();
   const file = tempDir.join("file.json");
   const json: { foo?: number } = file.readJSONSync({ fallback: { foo: 4 } });
   expect(json).toEqual({ foo: 4 });
@@ -186,7 +188,7 @@ test(".readJSONSync(…) with fallback", () => {
 });
 
 test(".writeSync(…)", () => {
-  const tempDir = Path.makeTempDirSync();
+  const tempDir = PathSync.makeTempDirSync();
   const file = tempDir.join("file.json");
   expect(file.writeSync("foo")).toBe(file);
 
@@ -202,14 +204,14 @@ test(".writeSync(…)", () => {
 });
 
 test(".writeJSONSync(…)", () => {
-  const file = Path.makeTempDirSync().join("file.json");
+  const file = PathSync.makeTempDirSync().join("file.json");
   expect(file.writeJSONSync({ foo: "bar" })).toBe(file);
 
   expect(file.readJSONSync()).toEqual<Record<string, string>>({ foo: "bar" });
 });
 
 test(".appendFileSync(…)", () => {
-  const file = Path.makeTempDirSync().join("file.txt");
+  const file = PathSync.makeTempDirSync().join("file.txt");
   file.appendFileSync("test\n");
   expect(file.readTextSync()).toEqual("test\n");
   file.appendFileSync("more\n");
@@ -217,7 +219,7 @@ test(".appendFileSync(…)", () => {
 });
 
 test(".readDirSync(…)", () => {
-  const dir = Path.makeTempDirSync();
+  const dir = PathSync.makeTempDirSync();
   dir.join("file.txt").writeSync("hello");
   dir.join("dir/file.json").writeSync("hello");
 
@@ -231,7 +233,7 @@ test(".readDirSync(…)", () => {
 });
 
 test(".symlinkSync(…)", () => {
-  const tempDir = Path.makeTempDirSync();
+  const tempDir = PathSync.makeTempDirSync();
   const source = tempDir.join("foo.txt");
   const target = tempDir.join("bar.txt");
   source.symlinkSync(target);
@@ -243,7 +245,7 @@ test(".symlinkSync(…)", () => {
 });
 
 test(".realpathSync(…)", () => {
-  const tempDir = Path.makeTempDirSync();
+  const tempDir = PathSync.makeTempDirSync();
   const source = tempDir.join("foo.txt");
   source.writeSync("hello world!");
   const target = tempDir.join("bar.txt");
@@ -252,7 +254,7 @@ test(".realpathSync(…)", () => {
 });
 
 test(".statSync(…)", () => {
-  const file = Path.makeTempDirSync().join("foo.txt");
+  const file = PathSync.makeTempDirSync().join("foo.txt");
   file.writeSync("hello");
 
   expect(file.statSync()?.size).toEqual(5);
@@ -261,7 +263,7 @@ test(".statSync(…)", () => {
 });
 
 test(".lstatSync(…)", () => {
-  const tempDir = Path.makeTempDirSync();
+  const tempDir = PathSync.makeTempDirSync();
   const source = tempDir.join("foo.txt");
   const target = tempDir.join("bar.txt");
   source.symlinkSync(target);
@@ -272,3 +274,41 @@ test(".lstatSync(…)", () => {
 
   expect(target.readTextSync()).toEqual("hello");
 });
+
+test(".chmodSync(…)", () => {
+  const binPath = PathSync.makeTempDirSync().join("nonexistent.bin");
+  expect(() => new PrintableShellCommand(binPath, []).text()).toThrow(
+    /ENOENT|Premature close/,
+  );
+  binPath.writeSync(`#!/usr/bin/env bash
+
+echo hi`);
+  // TODO: why doesn't this work here instead (but works in `printable-shell-comand`)?
+  //    binPath.writeSync(`#!/usr/bin/env -S bun run --
+
+  // console.log("hi");`);
+  expect(() => new PrintableShellCommand(binPath, []).text()).toThrow(
+    /EACCES|Premature close/,
+  );
+  binPath.chmodSync(0o755);
+  expect(() => new PrintableShellCommand(binPath, []).text()).not.toThrow();
+});
+
+test(".chmodXSync(…)", () => {
+  const binPath = PathSync.makeTempDirSync().join("nonexistent.bin");
+  expect(() => new PrintableShellCommand(binPath, []).text()).toThrow(
+    /ENOENT|Premature close/,
+  );
+  binPath.writeSync(`#!/usr/bin/env bash
+
+echo hi`);
+  // TODO: why doesn't this work here instead (but works in `printable-shell-comand`)?
+  //    binPath.writeSync(`#!/usr/bin/env -S bun run --
+
+  // console.log("hi");`);
+  expect(() => new PrintableShellCommand(binPath, []).text()).toThrow(
+    /EACCES|Premature close/,
+  );
+  binPath.chmodXSync();
+  expect(() => new PrintableShellCommand(binPath, []).text()).not.toThrow();
+});