@duplojs/server 0.0.0-stage → 0.1.0-beta.2

package/dist/file/readJsonFile.cjs

@@ -0,0 +1,33 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_implementor = require("../implementor.cjs");
+let _duplojs_lang_either = require("@duplojs/lang/either");
+_duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
+//#region scripts/file/readJsonFile.ts
+function handleNodeReadJsonFileError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-read-json-file-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-read-json-file-permission-denied", error);
+		else if (error.code === "EISDIR") return _duplojs_lang_either.left("file-system-read-json-file-is-directory", error);
+		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-read-json-file-not-directory", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-read-json-file-too-many-open-files", error);
+		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-read-json-file-busy", error);
+	}
+	return _duplojs_lang_either.left("file-system-read-json-file-error", error);
+}
+function handleDenoReadJsonFileError(error) {
+	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-read-json-file-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-read-json-file-permission-denied", error);
+	if (error instanceof Deno.errors.IsADirectory) return _duplojs_lang_either.left("file-system-read-json-file-is-directory", error);
+	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-read-json-file-not-directory", error);
+	if (error instanceof Deno.errors.Busy) return _duplojs_lang_either.left("file-system-read-json-file-busy", error);
+	return _duplojs_lang_either.left("file-system-read-json-file-error", error);
+}
+const readJsonFile = require_implementor.implementFunction("readJsonFile", {
+	NODE: async (path) => {
+		return (await require_implementor.nodeFileSystem.value).readFile(path, { encoding: "utf-8" }).then(JSON.parse).then((value) => _duplojs_lang_either.right("file-system-read-json-file", value)).catch(handleNodeReadJsonFileError);
+	},
+	DENO: (path) => Deno.readTextFile(path).then(JSON.parse).then((value) => _duplojs_lang_either.right("file-system-read-json-file", value)).catch(handleDenoReadJsonFileError),
+	BUN: (path) => Bun.file(path).text().then(JSON.parse).then((value) => _duplojs_lang_either.right("file-system-read-json-file", value)).catch(handleNodeReadJsonFileError)
+});
+//#endregion
+exports.readJsonFile = readJsonFile;

package/dist/file/readJsonFile.d.ts

@@ -0,0 +1,11 @@
+import { FileSystemEither } from './types';
+import type * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+import type * as DPath from "@duplojs/lang/path";
+export type ReadJsonFileResult = FileSystemEither<DEither.Right<"read-json-file", DCommon.Json> | DEither.Left<"read-json-file-not-found", unknown> | DEither.Left<"read-json-file-permission-denied", unknown> | DEither.Left<"read-json-file-is-directory", unknown> | DEither.Left<"read-json-file-not-directory", unknown> | DEither.Left<"read-json-file-too-many-open-files", unknown> | DEither.Left<"read-json-file-busy", unknown> | DEither.Left<"read-json-file-error", unknown>>;
+declare module '../implementor' {
+    interface ServerFunction {
+        readJsonFile(path: string & DPath.Path): Promise<ReadJsonFileResult>;
+    }
+}
+export declare const readJsonFile: (path: string & DPath.Path) => Promise<ReadJsonFileResult>;

package/dist/file/readJsonFile.mjs

@@ -0,0 +1,31 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/file/readJsonFile.ts
+function handleNodeReadJsonFileError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return DEither.left("file-system-read-json-file-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-read-json-file-permission-denied", error);
+		else if (error.code === "EISDIR") return DEither.left("file-system-read-json-file-is-directory", error);
+		else if (error.code === "ENOTDIR") return DEither.left("file-system-read-json-file-not-directory", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-read-json-file-too-many-open-files", error);
+		else if (error.code === "EBUSY") return DEither.left("file-system-read-json-file-busy", error);
+	}
+	return DEither.left("file-system-read-json-file-error", error);
+}
+function handleDenoReadJsonFileError(error) {
+	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-read-json-file-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-read-json-file-permission-denied", error);
+	if (error instanceof Deno.errors.IsADirectory) return DEither.left("file-system-read-json-file-is-directory", error);
+	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-read-json-file-not-directory", error);
+	if (error instanceof Deno.errors.Busy) return DEither.left("file-system-read-json-file-busy", error);
+	return DEither.left("file-system-read-json-file-error", error);
+}
+const readJsonFile = implementFunction("readJsonFile", {
+	NODE: async (path) => {
+		return (await nodeFileSystem.value).readFile(path, { encoding: "utf-8" }).then(JSON.parse).then((value) => DEither.right("file-system-read-json-file", value)).catch(handleNodeReadJsonFileError);
+	},
+	DENO: (path) => Deno.readTextFile(path).then(JSON.parse).then((value) => DEither.right("file-system-read-json-file", value)).catch(handleDenoReadJsonFileError),
+	BUN: (path) => Bun.file(path).text().then(JSON.parse).then((value) => DEither.right("file-system-read-json-file", value)).catch(handleNodeReadJsonFileError)
+});
+//#endregion
+export { readJsonFile };

package/dist/file/readLink.cjs

@@ -0,0 +1,30 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_implementor = require("../implementor.cjs");
+let _duplojs_lang_either = require("@duplojs/lang/either");
+_duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
+//#region scripts/file/readLink.ts
+function handleNodeReadLinkError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-read-link-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-read-link-permission-denied", error);
+		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-read-link-invalid-argument", error);
+		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-read-link-not-directory", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-read-link-too-many-open-files", error);
+	}
+	return _duplojs_lang_either.left("file-system-read-link-error", error);
+}
+function handleDenoReadLinkError(error) {
+	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-read-link-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-read-link-permission-denied", error);
+	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-read-link-invalid-argument", error);
+	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-read-link-not-directory", error);
+	return _duplojs_lang_either.left("file-system-read-link-error", error);
+}
+const readLink = require_implementor.implementFunction("readLink", {
+	NODE: async (path) => {
+		return (await require_implementor.nodeFileSystem.value).readlink(path, { encoding: "utf-8" }).then((value) => _duplojs_lang_either.right("file-system-read-link", value)).catch(handleNodeReadLinkError);
+	},
+	DENO: (path) => Deno.readLink(path).then((value) => _duplojs_lang_either.right("file-system-read-link", value)).catch(handleDenoReadLinkError)
+});
+//#endregion
+exports.readLink = readLink;

package/dist/file/readLink.d.ts

@@ -0,0 +1,10 @@
+import { FileSystemEither } from './types';
+import * as DEither from "@duplojs/lang/either";
+import type * as DPath from "@duplojs/lang/path";
+export type ReadLinkResult = FileSystemEither<DEither.Right<"read-link", string> | DEither.Left<"read-link-not-found", unknown> | DEither.Left<"read-link-permission-denied", unknown> | DEither.Left<"read-link-invalid-argument", unknown> | DEither.Left<"read-link-not-directory", unknown> | DEither.Left<"read-link-too-many-open-files", unknown> | DEither.Left<"read-link-error", unknown>>;
+declare module '../implementor' {
+    interface ServerFunction {
+        readLink(path: string & DPath.Path): Promise<ReadLinkResult>;
+    }
+}
+export declare const readLink: (path: string & DPath.Path) => Promise<ReadLinkResult>;

package/dist/file/readLink.mjs

@@ -0,0 +1,28 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/file/readLink.ts
+function handleNodeReadLinkError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return DEither.left("file-system-read-link-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-read-link-permission-denied", error);
+		else if (error.code === "EINVAL") return DEither.left("file-system-read-link-invalid-argument", error);
+		else if (error.code === "ENOTDIR") return DEither.left("file-system-read-link-not-directory", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-read-link-too-many-open-files", error);
+	}
+	return DEither.left("file-system-read-link-error", error);
+}
+function handleDenoReadLinkError(error) {
+	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-read-link-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-read-link-permission-denied", error);
+	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-read-link-invalid-argument", error);
+	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-read-link-not-directory", error);
+	return DEither.left("file-system-read-link-error", error);
+}
+const readLink = implementFunction("readLink", {
+	NODE: async (path) => {
+		return (await nodeFileSystem.value).readlink(path, { encoding: "utf-8" }).then((value) => DEither.right("file-system-read-link", value)).catch(handleNodeReadLinkError);
+	},
+	DENO: (path) => Deno.readLink(path).then((value) => DEither.right("file-system-read-link", value)).catch(handleDenoReadLinkError)
+});
+//#endregion
+export { readLink };

package/dist/file/readTextFile.cjs

@@ -0,0 +1,33 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_implementor = require("../implementor.cjs");
+let _duplojs_lang_either = require("@duplojs/lang/either");
+_duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
+//#region scripts/file/readTextFile.ts
+function handleNodeReadTextFileError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-read-text-file-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-read-text-file-permission-denied", error);
+		else if (error.code === "EISDIR") return _duplojs_lang_either.left("file-system-read-text-file-is-directory", error);
+		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-read-text-file-not-directory", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-read-text-file-too-many-open-files", error);
+		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-read-text-file-busy", error);
+	}
+	return _duplojs_lang_either.left("file-system-read-text-file-error", error);
+}
+function handleDenoReadTextFileError(error) {
+	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-read-text-file-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-read-text-file-permission-denied", error);
+	if (error instanceof Deno.errors.IsADirectory) return _duplojs_lang_either.left("file-system-read-text-file-is-directory", error);
+	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-read-text-file-not-directory", error);
+	if (error instanceof Deno.errors.Busy) return _duplojs_lang_either.left("file-system-read-text-file-busy", error);
+	return _duplojs_lang_either.left("file-system-read-text-file-error", error);
+}
+const readTextFile = require_implementor.implementFunction("readTextFile", {
+	NODE: async (path) => {
+		return (await require_implementor.nodeFileSystem.value).readFile(path, { encoding: "utf-8" }).then((value) => _duplojs_lang_either.right("file-system-read-text-file", value)).catch(handleNodeReadTextFileError);
+	},
+	DENO: (path) => Deno.readTextFile(path).then((value) => _duplojs_lang_either.right("file-system-read-text-file", value)).catch(handleDenoReadTextFileError),
+	BUN: (path) => Bun.file(path).text().then((value) => _duplojs_lang_either.right("file-system-read-text-file", value)).catch(handleNodeReadTextFileError)
+});
+//#endregion
+exports.readTextFile = readTextFile;

package/dist/file/readTextFile.d.ts

@@ -0,0 +1,10 @@
+import { FileSystemEither } from './types';
+import * as DEither from "@duplojs/lang/either";
+import type * as DPath from "@duplojs/lang/path";
+export type ReadTextFileResult = FileSystemEither<DEither.Right<"read-text-file", string> | DEither.Left<"read-text-file-not-found", unknown> | DEither.Left<"read-text-file-permission-denied", unknown> | DEither.Left<"read-text-file-is-directory", unknown> | DEither.Left<"read-text-file-not-directory", unknown> | DEither.Left<"read-text-file-too-many-open-files", unknown> | DEither.Left<"read-text-file-busy", unknown> | DEither.Left<"read-text-file-error", unknown>>;
+declare module '../implementor' {
+    interface ServerFunction {
+        readTextFile(path: string & DPath.Path): Promise<ReadTextFileResult>;
+    }
+}
+export declare const readTextFile: (path: string & DPath.Path) => Promise<ReadTextFileResult>;

package/dist/file/readTextFile.mjs

@@ -0,0 +1,31 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/file/readTextFile.ts
+function handleNodeReadTextFileError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return DEither.left("file-system-read-text-file-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-read-text-file-permission-denied", error);
+		else if (error.code === "EISDIR") return DEither.left("file-system-read-text-file-is-directory", error);
+		else if (error.code === "ENOTDIR") return DEither.left("file-system-read-text-file-not-directory", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-read-text-file-too-many-open-files", error);
+		else if (error.code === "EBUSY") return DEither.left("file-system-read-text-file-busy", error);
+	}
+	return DEither.left("file-system-read-text-file-error", error);
+}
+function handleDenoReadTextFileError(error) {
+	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-read-text-file-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-read-text-file-permission-denied", error);
+	if (error instanceof Deno.errors.IsADirectory) return DEither.left("file-system-read-text-file-is-directory", error);
+	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-read-text-file-not-directory", error);
+	if (error instanceof Deno.errors.Busy) return DEither.left("file-system-read-text-file-busy", error);
+	return DEither.left("file-system-read-text-file-error", error);
+}
+const readTextFile = implementFunction("readTextFile", {
+	NODE: async (path) => {
+		return (await nodeFileSystem.value).readFile(path, { encoding: "utf-8" }).then((value) => DEither.right("file-system-read-text-file", value)).catch(handleNodeReadTextFileError);
+	},
+	DENO: (path) => Deno.readTextFile(path).then((value) => DEither.right("file-system-read-text-file", value)).catch(handleDenoReadTextFileError),
+	BUN: (path) => Bun.file(path).text().then((value) => DEither.right("file-system-read-text-file", value)).catch(handleNodeReadTextFileError)
+});
+//#endregion
+export { readTextFile };

package/dist/file/realPath.cjs

@@ -0,0 +1,28 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_implementor = require("../implementor.cjs");
+let _duplojs_lang_either = require("@duplojs/lang/either");
+_duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
+//#region scripts/file/realPath.ts
+function handleNodeRealPathError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-real-path-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-real-path-permission-denied", error);
+		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-real-path-not-directory", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-real-path-too-many-open-files", error);
+	}
+	return _duplojs_lang_either.left("file-system-real-path-error", error);
+}
+function handleDenoRealPathError(error) {
+	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-real-path-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-real-path-permission-denied", error);
+	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-real-path-not-directory", error);
+	return _duplojs_lang_either.left("file-system-real-path-error", error);
+}
+const realPath = require_implementor.implementFunction("realPath", {
+	NODE: async (path) => {
+		return (await require_implementor.nodeFileSystem.value).realpath(path).then((value) => _duplojs_lang_either.right("file-system-real-path", value)).catch(handleNodeRealPathError);
+	},
+	DENO: (path) => Deno.realPath(path).then((value) => _duplojs_lang_either.right("file-system-real-path", value)).catch(handleDenoRealPathError)
+});
+//#endregion
+exports.realPath = realPath;

package/dist/file/realPath.d.ts

@@ -0,0 +1,10 @@
+import { FileSystemEither } from './types';
+import * as DEither from "@duplojs/lang/either";
+import type * as DPath from "@duplojs/lang/path";
+export type RealPathResult = FileSystemEither<DEither.Right<"real-path", string> | DEither.Left<"real-path-not-found", unknown> | DEither.Left<"real-path-permission-denied", unknown> | DEither.Left<"real-path-not-directory", unknown> | DEither.Left<"real-path-too-many-open-files", unknown> | DEither.Left<"real-path-error", unknown>>;
+declare module '../implementor' {
+    interface ServerFunction {
+        realPath(path: string & DPath.Path): Promise<RealPathResult>;
+    }
+}
+export declare const realPath: (path: string & DPath.Path) => Promise<RealPathResult>;

package/dist/file/realPath.mjs

@@ -0,0 +1,26 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/file/realPath.ts
+function handleNodeRealPathError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return DEither.left("file-system-real-path-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-real-path-permission-denied", error);
+		else if (error.code === "ENOTDIR") return DEither.left("file-system-real-path-not-directory", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-real-path-too-many-open-files", error);
+	}
+	return DEither.left("file-system-real-path-error", error);
+}
+function handleDenoRealPathError(error) {
+	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-real-path-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-real-path-permission-denied", error);
+	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-real-path-not-directory", error);
+	return DEither.left("file-system-real-path-error", error);
+}
+const realPath = implementFunction("realPath", {
+	NODE: async (path) => {
+		return (await nodeFileSystem.value).realpath(path).then((value) => DEither.right("file-system-real-path", value)).catch(handleNodeRealPathError);
+	},
+	DENO: (path) => Deno.realPath(path).then((value) => DEither.right("file-system-real-path", value)).catch(handleDenoRealPathError)
+});
+//#endregion
+export { realPath };

package/dist/file/relocate.cjs

@@ -0,0 +1,56 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_implementor = require("../implementor.cjs");
+let _duplojs_lang_either = require("@duplojs/lang/either");
+_duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
+let _duplojs_lang_path = require("@duplojs/lang/path");
+_duplojs_lang_path = require_runtime.__toESM(_duplojs_lang_path, 1);
+//#region scripts/file/relocate.ts
+function handleNodeRelocateError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-relocate-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-relocate-permission-denied", error);
+		else if (error.code === "EEXIST") return _duplojs_lang_either.left("file-system-relocate-already-exists", error);
+		else if (error.code === "EISDIR") return _duplojs_lang_either.left("file-system-relocate-is-directory", error);
+		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-relocate-not-directory", error);
+		else if (error.code === "ENOTEMPTY") return _duplojs_lang_either.left("file-system-relocate-directory-not-empty", error);
+		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-relocate-read-only", error);
+		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-relocate-invalid-argument", error);
+		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-relocate-busy", error);
+		else if (error.code === "EXDEV") return _duplojs_lang_either.left("file-system-relocate-cross-device", error);
+	}
+	return _duplojs_lang_either.left("file-system-relocate-error", error);
+}
+function handleDenoRelocateError(error) {
+	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-relocate-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-relocate-permission-denied", error);
+	if (error instanceof Deno.errors.AlreadyExists) return _duplojs_lang_either.left("file-system-relocate-already-exists", error);
+	if (error instanceof Deno.errors.IsADirectory) return _duplojs_lang_either.left("file-system-relocate-is-directory", error);
+	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-relocate-not-directory", error);
+	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-relocate-invalid-argument", error);
+	if (error instanceof Deno.errors.Busy) return _duplojs_lang_either.left("file-system-relocate-busy", error);
+	return _duplojs_lang_either.left("file-system-relocate-error", error);
+}
+const relocateImplementation = require_implementor.implementFunction("relocate", {
+	NODE: async (fromPath, newParentPath) => {
+		const fs = await require_implementor.nodeFileSystem.value;
+		const baseName = _duplojs_lang_path.getBaseName(fromPath);
+		if (!baseName) return _duplojs_lang_either.left("file-system-relocate-invalid-argument", /* @__PURE__ */ new Error(`Invalid base name ${fromPath}`));
+		const newPath = _duplojs_lang_path.resolveRelative([newParentPath, baseName]);
+		return fs.rename(fromPath, newPath).then(() => _duplojs_lang_either.right("file-system-relocate", newPath)).catch(handleNodeRelocateError);
+	},
+	DENO: (fromPath, newParentPath) => {
+		const baseName = _duplojs_lang_path.getBaseName(fromPath);
+		if (!baseName) return Promise.resolve(_duplojs_lang_either.left("file-system-relocate-invalid-argument", /* @__PURE__ */ new Error(`Invalid base name ${fromPath}`)));
+		const newPath = _duplojs_lang_path.resolveRelative([newParentPath, baseName]);
+		return Deno.rename(fromPath, newPath).then(() => _duplojs_lang_either.right("file-system-relocate", newPath)).catch(handleDenoRelocateError);
+	}
+});
+function relocate(...args) {
+	if (args.length === 1) {
+		const [toPath] = args;
+		return (fromPath) => relocateImplementation(fromPath, toPath);
+	}
+	return relocateImplementation(...args);
+}
+//#endregion
+exports.relocate = relocate;

package/dist/file/relocate.d.ts

@@ -0,0 +1,11 @@
+import { FileSystemEither } from './types';
+import * as DPath from "@duplojs/lang/path";
+import * as DEither from "@duplojs/lang/either";
+export type RelocateResult = FileSystemEither<DEither.Right<"relocate", string & DPath.Path> | DEither.Left<"relocate-not-found", unknown> | DEither.Left<"relocate-permission-denied", unknown> | DEither.Left<"relocate-already-exists", unknown> | DEither.Left<"relocate-is-directory", unknown> | DEither.Left<"relocate-not-directory", unknown> | DEither.Left<"relocate-directory-not-empty", unknown> | DEither.Left<"relocate-read-only", unknown> | DEither.Left<"relocate-invalid-argument", unknown> | DEither.Left<"relocate-busy", unknown> | DEither.Left<"relocate-cross-device", unknown> | DEither.Left<"relocate-error", unknown>>;
+declare module '../implementor' {
+    interface ServerFunction {
+        relocate(fromPath: string & DPath.Path, toPath: string & DPath.Path): Promise<RelocateResult>;
+    }
+}
+export declare function relocate(toPath: string & DPath.Path): (fromPath: string & DPath.Path) => Promise<RelocateResult>;
+export declare function relocate(fromPath: string & DPath.Path, toPath: string & DPath.Path): Promise<RelocateResult>;

package/dist/file/relocate.mjs

@@ -0,0 +1,53 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DEither from "@duplojs/lang/either";
+import * as DPath from "@duplojs/lang/path";
+//#region scripts/file/relocate.ts
+function handleNodeRelocateError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return DEither.left("file-system-relocate-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-relocate-permission-denied", error);
+		else if (error.code === "EEXIST") return DEither.left("file-system-relocate-already-exists", error);
+		else if (error.code === "EISDIR") return DEither.left("file-system-relocate-is-directory", error);
+		else if (error.code === "ENOTDIR") return DEither.left("file-system-relocate-not-directory", error);
+		else if (error.code === "ENOTEMPTY") return DEither.left("file-system-relocate-directory-not-empty", error);
+		else if (error.code === "EROFS") return DEither.left("file-system-relocate-read-only", error);
+		else if (error.code === "EINVAL") return DEither.left("file-system-relocate-invalid-argument", error);
+		else if (error.code === "EBUSY") return DEither.left("file-system-relocate-busy", error);
+		else if (error.code === "EXDEV") return DEither.left("file-system-relocate-cross-device", error);
+	}
+	return DEither.left("file-system-relocate-error", error);
+}
+function handleDenoRelocateError(error) {
+	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-relocate-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-relocate-permission-denied", error);
+	if (error instanceof Deno.errors.AlreadyExists) return DEither.left("file-system-relocate-already-exists", error);
+	if (error instanceof Deno.errors.IsADirectory) return DEither.left("file-system-relocate-is-directory", error);
+	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-relocate-not-directory", error);
+	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-relocate-invalid-argument", error);
+	if (error instanceof Deno.errors.Busy) return DEither.left("file-system-relocate-busy", error);
+	return DEither.left("file-system-relocate-error", error);
+}
+const relocateImplementation = implementFunction("relocate", {
+	NODE: async (fromPath, newParentPath) => {
+		const fs = await nodeFileSystem.value;
+		const baseName = DPath.getBaseName(fromPath);
+		if (!baseName) return DEither.left("file-system-relocate-invalid-argument", /* @__PURE__ */ new Error(`Invalid base name ${fromPath}`));
+		const newPath = DPath.resolveRelative([newParentPath, baseName]);
+		return fs.rename(fromPath, newPath).then(() => DEither.right("file-system-relocate", newPath)).catch(handleNodeRelocateError);
+	},
+	DENO: (fromPath, newParentPath) => {
+		const baseName = DPath.getBaseName(fromPath);
+		if (!baseName) return Promise.resolve(DEither.left("file-system-relocate-invalid-argument", /* @__PURE__ */ new Error(`Invalid base name ${fromPath}`)));
+		const newPath = DPath.resolveRelative([newParentPath, baseName]);
+		return Deno.rename(fromPath, newPath).then(() => DEither.right("file-system-relocate", newPath)).catch(handleDenoRelocateError);
+	}
+});
+function relocate(...args) {
+	if (args.length === 1) {
+		const [toPath] = args;
+		return (fromPath) => relocateImplementation(fromPath, toPath);
+	}
+	return relocateImplementation(...args);
+}
+//#endregion
+export { relocate };

package/dist/file/remove.cjs

@@ -0,0 +1,38 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_implementor = require("../implementor.cjs");
+let _duplojs_lang_either = require("@duplojs/lang/either");
+_duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
+//#region scripts/file/remove.ts
+function handleNodeRemoveError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-remove-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-remove-permission-denied", error);
+		else if (error.code === "EISDIR") return _duplojs_lang_either.left("file-system-remove-is-directory", error);
+		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-remove-not-directory", error);
+		else if (error.code === "ENOTEMPTY") return _duplojs_lang_either.left("file-system-remove-directory-not-empty", error);
+		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-remove-read-only", error);
+		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-remove-invalid-argument", error);
+		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-remove-busy", error);
+	}
+	return _duplojs_lang_either.left("file-system-remove-error", error);
+}
+function handleDenoRemoveError(error) {
+	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-remove-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-remove-permission-denied", error);
+	if (error instanceof Deno.errors.IsADirectory) return _duplojs_lang_either.left("file-system-remove-is-directory", error);
+	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-remove-not-directory", error);
+	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-remove-invalid-argument", error);
+	if (error instanceof Deno.errors.Busy) return _duplojs_lang_either.left("file-system-remove-busy", error);
+	return _duplojs_lang_either.left("file-system-remove-error", error);
+}
+const remove = require_implementor.implementFunction("remove", {
+	NODE: async (path, params) => {
+		return (await require_implementor.nodeFileSystem.value).rm(path, {
+			recursive: params?.recursive ?? false,
+			force: true
+		}).then(() => _duplojs_lang_either.right("file-system-remove")).catch(handleNodeRemoveError);
+	},
+	DENO: (path, params) => Deno.remove(path, { recursive: params?.recursive }).then(() => _duplojs_lang_either.right("file-system-remove")).catch(handleDenoRemoveError)
+});
+//#endregion
+exports.remove = remove;

package/dist/file/remove.d.ts

@@ -0,0 +1,14 @@
+import { FileSystemEither } from './types';
+import * as DEither from "@duplojs/lang/either";
+import type * as DPath from "@duplojs/lang/path";
+interface RemoveDirectoryParams {
+    recursive?: boolean;
+}
+export type RemoveResult = FileSystemEither<DEither.Right<"remove", void> | DEither.Left<"remove-not-found", unknown> | DEither.Left<"remove-permission-denied", unknown> | DEither.Left<"remove-is-directory", unknown> | DEither.Left<"remove-not-directory", unknown> | DEither.Left<"remove-directory-not-empty", unknown> | DEither.Left<"remove-read-only", unknown> | DEither.Left<"remove-invalid-argument", unknown> | DEither.Left<"remove-busy", unknown> | DEither.Left<"remove-error", unknown>>;
+declare module '../implementor' {
+    interface ServerFunction {
+        remove(path: string & DPath.Path, params?: RemoveDirectoryParams): Promise<RemoveResult>;
+    }
+}
+export declare const remove: (path: string & DPath.Path, params?: RemoveDirectoryParams) => Promise<RemoveResult>;
+export {};

package/dist/file/remove.mjs

@@ -0,0 +1,36 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/file/remove.ts
+function handleNodeRemoveError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return DEither.left("file-system-remove-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-remove-permission-denied", error);
+		else if (error.code === "EISDIR") return DEither.left("file-system-remove-is-directory", error);
+		else if (error.code === "ENOTDIR") return DEither.left("file-system-remove-not-directory", error);
+		else if (error.code === "ENOTEMPTY") return DEither.left("file-system-remove-directory-not-empty", error);
+		else if (error.code === "EROFS") return DEither.left("file-system-remove-read-only", error);
+		else if (error.code === "EINVAL") return DEither.left("file-system-remove-invalid-argument", error);
+		else if (error.code === "EBUSY") return DEither.left("file-system-remove-busy", error);
+	}
+	return DEither.left("file-system-remove-error", error);
+}
+function handleDenoRemoveError(error) {
+	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-remove-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-remove-permission-denied", error);
+	if (error instanceof Deno.errors.IsADirectory) return DEither.left("file-system-remove-is-directory", error);
+	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-remove-not-directory", error);
+	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-remove-invalid-argument", error);
+	if (error instanceof Deno.errors.Busy) return DEither.left("file-system-remove-busy", error);
+	return DEither.left("file-system-remove-error", error);
+}
+const remove = implementFunction("remove", {
+	NODE: async (path, params) => {
+		return (await nodeFileSystem.value).rm(path, {
+			recursive: params?.recursive ?? false,
+			force: true
+		}).then(() => DEither.right("file-system-remove")).catch(handleNodeRemoveError);
+	},
+	DENO: (path, params) => Deno.remove(path, { recursive: params?.recursive }).then(() => DEither.right("file-system-remove")).catch(handleDenoRemoveError)
+});
+//#endregion
+export { remove };

package/dist/file/rename.cjs

@@ -0,0 +1,56 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_implementor = require("../implementor.cjs");
+let _duplojs_lang_either = require("@duplojs/lang/either");
+_duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
+let _duplojs_lang_path = require("@duplojs/lang/path");
+_duplojs_lang_path = require_runtime.__toESM(_duplojs_lang_path, 1);
+//#region scripts/file/rename.ts
+function handleNodeRenameError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-rename-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-rename-permission-denied", error);
+		else if (error.code === "EEXIST") return _duplojs_lang_either.left("file-system-rename-already-exists", error);
+		else if (error.code === "EISDIR") return _duplojs_lang_either.left("file-system-rename-is-directory", error);
+		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-rename-not-directory", error);
+		else if (error.code === "ENOTEMPTY") return _duplojs_lang_either.left("file-system-rename-directory-not-empty", error);
+		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-rename-read-only", error);
+		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-rename-invalid-argument", error);
+		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-rename-busy", error);
+		else if (error.code === "EXDEV") return _duplojs_lang_either.left("file-system-rename-cross-device", error);
+	}
+	return _duplojs_lang_either.left("file-system-rename-error", error);
+}
+function handleDenoRenameError(error) {
+	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-rename-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-rename-permission-denied", error);
+	if (error instanceof Deno.errors.AlreadyExists) return _duplojs_lang_either.left("file-system-rename-already-exists", error);
+	if (error instanceof Deno.errors.IsADirectory) return _duplojs_lang_either.left("file-system-rename-is-directory", error);
+	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-rename-not-directory", error);
+	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-rename-invalid-argument", error);
+	if (error instanceof Deno.errors.Busy) return _duplojs_lang_either.left("file-system-rename-busy", error);
+	return _duplojs_lang_either.left("file-system-rename-error", error);
+}
+const renameImplementation = require_implementor.implementFunction("rename", {
+	NODE: async (path, newName) => {
+		const fs = await require_implementor.nodeFileSystem.value;
+		const parentPath = _duplojs_lang_path.getParentFolderPath(path);
+		if (!parentPath) return _duplojs_lang_either.left("file-system-rename-invalid-argument", /* @__PURE__ */ new Error(`Invalid parent path ${path}.`));
+		const newPath = _duplojs_lang_path.resolveRelative([parentPath, newName]);
+		return fs.rename(path, newPath).then(() => _duplojs_lang_either.right("file-system-rename", newPath)).catch(handleNodeRenameError);
+	},
+	DENO: (path, newName) => {
+		const parentPath = _duplojs_lang_path.getParentFolderPath(path);
+		if (!parentPath) return Promise.resolve(_duplojs_lang_either.left("file-system-rename-invalid-argument", /* @__PURE__ */ new Error(`Invalid parent path ${path}.`)));
+		const newPath = _duplojs_lang_path.resolveRelative([parentPath, newName]);
+		return Deno.rename(path, newPath).then(() => _duplojs_lang_either.right("file-system-rename", newPath)).catch(handleDenoRenameError);
+	}
+});
+function rename(...args) {
+	if (args.length === 1) {
+		const [newName] = args;
+		return (path) => renameImplementation(path, newName);
+	}
+	return renameImplementation(...args);
+}
+//#endregion
+exports.rename = rename;

package/dist/file/rename.d.ts

@@ -0,0 +1,11 @@
+import { FileSystemEither } from './types';
+import * as DPath from "@duplojs/lang/path";
+import * as DEither from "@duplojs/lang/either";
+export type RenameResult = FileSystemEither<DEither.Right<"rename", string & DPath.Path> | DEither.Left<"rename-not-found", unknown> | DEither.Left<"rename-permission-denied", unknown> | DEither.Left<"rename-already-exists", unknown> | DEither.Left<"rename-is-directory", unknown> | DEither.Left<"rename-not-directory", unknown> | DEither.Left<"rename-directory-not-empty", unknown> | DEither.Left<"rename-read-only", unknown> | DEither.Left<"rename-invalid-argument", unknown> | DEither.Left<"rename-busy", unknown> | DEither.Left<"rename-cross-device", unknown> | DEither.Left<"rename-error", unknown>>;
+declare module '../implementor' {
+    interface ServerFunction {
+        rename(path: string & DPath.Path, newName: string & DPath.Segment): Promise<RenameResult>;
+    }
+}
+export declare function rename(newName: string & DPath.Segment): (path: string & DPath.Path) => Promise<RenameResult>;
+export declare function rename(path: string & DPath.Path, newName: string & DPath.Segment): Promise<RenameResult>;