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

package/dist/file/rename.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/rename.ts
+function handleNodeRenameError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return DEither.left("file-system-rename-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-rename-permission-denied", error);
+		else if (error.code === "EEXIST") return DEither.left("file-system-rename-already-exists", error);
+		else if (error.code === "EISDIR") return DEither.left("file-system-rename-is-directory", error);
+		else if (error.code === "ENOTDIR") return DEither.left("file-system-rename-not-directory", error);
+		else if (error.code === "ENOTEMPTY") return DEither.left("file-system-rename-directory-not-empty", error);
+		else if (error.code === "EROFS") return DEither.left("file-system-rename-read-only", error);
+		else if (error.code === "EINVAL") return DEither.left("file-system-rename-invalid-argument", error);
+		else if (error.code === "EBUSY") return DEither.left("file-system-rename-busy", error);
+		else if (error.code === "EXDEV") return DEither.left("file-system-rename-cross-device", error);
+	}
+	return DEither.left("file-system-rename-error", error);
+}
+function handleDenoRenameError(error) {
+	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-rename-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-rename-permission-denied", error);
+	if (error instanceof Deno.errors.AlreadyExists) return DEither.left("file-system-rename-already-exists", error);
+	if (error instanceof Deno.errors.IsADirectory) return DEither.left("file-system-rename-is-directory", error);
+	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-rename-not-directory", error);
+	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-rename-invalid-argument", error);
+	if (error instanceof Deno.errors.Busy) return DEither.left("file-system-rename-busy", error);
+	return DEither.left("file-system-rename-error", error);
+}
+const renameImplementation = implementFunction("rename", {
+	NODE: async (path, newName) => {
+		const fs = await nodeFileSystem.value;
+		const parentPath = DPath.getParentFolderPath(path);
+		if (!parentPath) return DEither.left("file-system-rename-invalid-argument", /* @__PURE__ */ new Error(`Invalid parent path ${path}.`));
+		const newPath = DPath.resolveRelative([parentPath, newName]);
+		return fs.rename(path, newPath).then(() => DEither.right("file-system-rename", newPath)).catch(handleNodeRenameError);
+	},
+	DENO: (path, newName) => {
+		const parentPath = DPath.getParentFolderPath(path);
+		if (!parentPath) return Promise.resolve(DEither.left("file-system-rename-invalid-argument", /* @__PURE__ */ new Error(`Invalid parent path ${path}.`)));
+		const newPath = DPath.resolveRelative([parentPath, newName]);
+		return Deno.rename(path, newPath).then(() => DEither.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
+export { rename };

package/dist/file/setMode.cjs

@@ -0,0 +1,51 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_implementor = require("../implementor.cjs");
+let _duplojs_lang_common = require("@duplojs/lang/common");
+_duplojs_lang_common = require_runtime.__toESM(_duplojs_lang_common, 1);
+let _duplojs_lang_either = require("@duplojs/lang/either");
+_duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
+//#region scripts/file/setMode.ts
+function handleNodeSetModeError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-set-mode-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-set-mode-permission-denied", error);
+		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-set-mode-not-directory", error);
+		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-set-mode-read-only", error);
+		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-set-mode-invalid-argument", error);
+	}
+	return _duplojs_lang_either.left("file-system-set-mode-error", error);
+}
+function handleDenoSetModeError(error) {
+	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-set-mode-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-set-mode-permission-denied", error);
+	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-set-mode-not-directory", error);
+	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-set-mode-invalid-argument", error);
+	return _duplojs_lang_either.left("file-system-set-mode-error", error);
+}
+function calculatePermissions(permissions) {
+	if (!permissions) return 0;
+	return (permissions.read ? 4 : 0) + (permissions.write ? 2 : 0) + (permissions.exec ? 1 : 0);
+}
+function toMode(mode) {
+	if (_duplojs_lang_common.isType(mode, "number")) return mode;
+	const special = (mode.setUserId ? 4 : 0) + (mode.setGroupId ? 2 : 0) + (mode.sticky ? 1 : 0);
+	const user = calculatePermissions(mode.user);
+	const group = calculatePermissions(mode.group);
+	const other = calculatePermissions(mode.other);
+	return special * 512 + user * 64 + group * 8 + other;
+}
+const setModeImplementation = require_implementor.implementFunction("setMode", {
+	NODE: async (path, mode) => {
+		return (await require_implementor.nodeFileSystem.value).chmod(path, toMode(mode)).then(() => _duplojs_lang_either.right("file-system-set-mode")).catch(handleNodeSetModeError);
+	},
+	DENO: (path, mode) => Deno.chmod(path, toMode(mode)).then(() => _duplojs_lang_either.right("file-system-set-mode")).catch(handleDenoSetModeError)
+});
+function setMode(...args) {
+	if (args.length === 1) {
+		const [mode] = args;
+		return (path) => setModeImplementation(path, mode);
+	}
+	return setModeImplementation(...args);
+}
+//#endregion
+exports.setMode = setMode;

package/dist/file/setMode.d.ts

@@ -0,0 +1,26 @@
+import { FileSystemEither } from './types';
+import * as DEither from "@duplojs/lang/either";
+import type * as DPath from "@duplojs/lang/path";
+interface Permissions {
+    read?: boolean;
+    write?: boolean;
+    exec?: boolean;
+}
+interface ModeObject {
+    user?: Permissions;
+    group?: Permissions;
+    other?: Permissions;
+    setUserId?: boolean;
+    setGroupId?: boolean;
+    sticky?: boolean;
+}
+type SetMode = ModeObject | number;
+export type SetModeResult = FileSystemEither<DEither.Right<"set-mode", void> | DEither.Left<"set-mode-not-found", unknown> | DEither.Left<"set-mode-permission-denied", unknown> | DEither.Left<"set-mode-not-directory", unknown> | DEither.Left<"set-mode-read-only", unknown> | DEither.Left<"set-mode-invalid-argument", unknown> | DEither.Left<"set-mode-error", unknown>>;
+declare module '../implementor' {
+    interface ServerFunction {
+        setMode(path: string & DPath.Path, mode: SetMode): Promise<SetModeResult>;
+    }
+}
+export declare function setMode(mode: SetMode): (path: string & DPath.Path) => Promise<SetModeResult>;
+export declare function setMode(path: string & DPath.Path, mode: SetMode): Promise<SetModeResult>;
+export {};

package/dist/file/setMode.mjs

@@ -0,0 +1,48 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/file/setMode.ts
+function handleNodeSetModeError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return DEither.left("file-system-set-mode-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-set-mode-permission-denied", error);
+		else if (error.code === "ENOTDIR") return DEither.left("file-system-set-mode-not-directory", error);
+		else if (error.code === "EROFS") return DEither.left("file-system-set-mode-read-only", error);
+		else if (error.code === "EINVAL") return DEither.left("file-system-set-mode-invalid-argument", error);
+	}
+	return DEither.left("file-system-set-mode-error", error);
+}
+function handleDenoSetModeError(error) {
+	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-set-mode-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-set-mode-permission-denied", error);
+	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-set-mode-not-directory", error);
+	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-set-mode-invalid-argument", error);
+	return DEither.left("file-system-set-mode-error", error);
+}
+function calculatePermissions(permissions) {
+	if (!permissions) return 0;
+	return (permissions.read ? 4 : 0) + (permissions.write ? 2 : 0) + (permissions.exec ? 1 : 0);
+}
+function toMode(mode) {
+	if (DCommon.isType(mode, "number")) return mode;
+	const special = (mode.setUserId ? 4 : 0) + (mode.setGroupId ? 2 : 0) + (mode.sticky ? 1 : 0);
+	const user = calculatePermissions(mode.user);
+	const group = calculatePermissions(mode.group);
+	const other = calculatePermissions(mode.other);
+	return special * 512 + user * 64 + group * 8 + other;
+}
+const setModeImplementation = implementFunction("setMode", {
+	NODE: async (path, mode) => {
+		return (await nodeFileSystem.value).chmod(path, toMode(mode)).then(() => DEither.right("file-system-set-mode")).catch(handleNodeSetModeError);
+	},
+	DENO: (path, mode) => Deno.chmod(path, toMode(mode)).then(() => DEither.right("file-system-set-mode")).catch(handleDenoSetModeError)
+});
+function setMode(...args) {
+	if (args.length === 1) {
+		const [mode] = args;
+		return (path) => setModeImplementation(path, mode);
+	}
+	return setModeImplementation(...args);
+}
+//#endregion
+export { setMode };

package/dist/file/setOwner.cjs

@@ -0,0 +1,37 @@
+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/setOwner.ts
+function handleNodeSetOwnerError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-set-owner-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-set-owner-permission-denied", error);
+		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-set-owner-not-directory", error);
+		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-set-owner-read-only", error);
+		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-set-owner-invalid-argument", error);
+	}
+	return _duplojs_lang_either.left("file-system-set-owner-error", error);
+}
+function handleDenoSetOwnerError(error) {
+	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-set-owner-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-set-owner-permission-denied", error);
+	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-set-owner-not-directory", error);
+	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-set-owner-invalid-argument", error);
+	return _duplojs_lang_either.left("file-system-set-owner-error", error);
+}
+const setOwnerImplementation = require_implementor.implementFunction("setOwner", {
+	NODE: async (path, { userId, groupId }) => {
+		return (await require_implementor.nodeFileSystem.value).chown(path, userId, groupId).then(() => _duplojs_lang_either.right("file-system-set-owner")).catch(handleNodeSetOwnerError);
+	},
+	DENO: (path, { userId, groupId }) => Deno.chown(path, userId, groupId).then(() => _duplojs_lang_either.right("file-system-set-owner")).catch(handleDenoSetOwnerError)
+});
+function setOwner(...args) {
+	if (args.length === 1) {
+		const [params] = args;
+		return (path) => setOwnerImplementation(path, params);
+	}
+	return setOwnerImplementation(...args);
+}
+//#endregion
+exports.setOwner = setOwner;

package/dist/file/setOwner.d.ts

@@ -0,0 +1,15 @@
+import { FileSystemEither } from './types';
+import * as DEither from "@duplojs/lang/either";
+import type * as DPath from "@duplojs/lang/path";
+export interface SetOwnerParams {
+    userId: number;
+    groupId: number;
+}
+export type SetOwnerResult = FileSystemEither<DEither.Right<"set-owner", void> | DEither.Left<"set-owner-not-found", unknown> | DEither.Left<"set-owner-permission-denied", unknown> | DEither.Left<"set-owner-not-directory", unknown> | DEither.Left<"set-owner-read-only", unknown> | DEither.Left<"set-owner-invalid-argument", unknown> | DEither.Left<"set-owner-error", unknown>>;
+declare module '../implementor' {
+    interface ServerFunction {
+        setOwner(path: string & DPath.Path, params: SetOwnerParams): Promise<SetOwnerResult>;
+    }
+}
+export declare function setOwner(params: SetOwnerParams): (path: string & DPath.Path) => Promise<SetOwnerResult>;
+export declare function setOwner(path: string & DPath.Path, params: SetOwnerParams): Promise<SetOwnerResult>;

package/dist/file/setOwner.mjs

@@ -0,0 +1,35 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/file/setOwner.ts
+function handleNodeSetOwnerError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return DEither.left("file-system-set-owner-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-set-owner-permission-denied", error);
+		else if (error.code === "ENOTDIR") return DEither.left("file-system-set-owner-not-directory", error);
+		else if (error.code === "EROFS") return DEither.left("file-system-set-owner-read-only", error);
+		else if (error.code === "EINVAL") return DEither.left("file-system-set-owner-invalid-argument", error);
+	}
+	return DEither.left("file-system-set-owner-error", error);
+}
+function handleDenoSetOwnerError(error) {
+	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-set-owner-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-set-owner-permission-denied", error);
+	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-set-owner-not-directory", error);
+	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-set-owner-invalid-argument", error);
+	return DEither.left("file-system-set-owner-error", error);
+}
+const setOwnerImplementation = implementFunction("setOwner", {
+	NODE: async (path, { userId, groupId }) => {
+		return (await nodeFileSystem.value).chown(path, userId, groupId).then(() => DEither.right("file-system-set-owner")).catch(handleNodeSetOwnerError);
+	},
+	DENO: (path, { userId, groupId }) => Deno.chown(path, userId, groupId).then(() => DEither.right("file-system-set-owner")).catch(handleDenoSetOwnerError)
+});
+function setOwner(...args) {
+	if (args.length === 1) {
+		const [params] = args;
+		return (path) => setOwnerImplementation(path, params);
+	}
+	return setOwnerImplementation(...args);
+}
+//#endregion
+export { setOwner };

package/dist/file/setTime.cjs

@@ -0,0 +1,39 @@
+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_chrono = require("@duplojs/lang/chrono");
+_duplojs_lang_chrono = require_runtime.__toESM(_duplojs_lang_chrono, 1);
+//#region scripts/file/setTime.ts
+function handleNodeSetTimeError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-set-time-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-set-time-permission-denied", error);
+		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-set-time-not-directory", error);
+		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-set-time-read-only", error);
+		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-set-time-invalid-argument", error);
+	}
+	return _duplojs_lang_either.left("file-system-set-time-error", error);
+}
+function handleDenoSetTimeError(error) {
+	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-set-time-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-set-time-permission-denied", error);
+	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-set-time-not-directory", error);
+	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-set-time-invalid-argument", error);
+	return _duplojs_lang_either.left("file-system-set-time-error", error);
+}
+const setTimeImplementation = require_implementor.implementFunction("setTime", {
+	NODE: async (path, { accessTime, modifiedTime }) => {
+		return (await require_implementor.nodeFileSystem.value).utimes(path, _duplojs_lang_chrono.toTimestamp(accessTime), _duplojs_lang_chrono.toTimestamp(modifiedTime)).then(() => _duplojs_lang_either.right("file-system-set-time")).catch(handleNodeSetTimeError);
+	},
+	DENO: (path, { accessTime, modifiedTime }) => Deno.utime(path, _duplojs_lang_chrono.toTimestamp(accessTime), _duplojs_lang_chrono.toTimestamp(modifiedTime)).then(() => _duplojs_lang_either.right("file-system-set-time")).catch(handleDenoSetTimeError)
+});
+function setTime(...args) {
+	if (args.length === 1) {
+		const [params] = args;
+		return (path) => setTimeImplementation(path, params);
+	}
+	return setTimeImplementation(...args);
+}
+//#endregion
+exports.setTime = setTime;

package/dist/file/setTime.d.ts

@@ -0,0 +1,17 @@
+import { FileSystemEither } from './types';
+import * as DEither from "@duplojs/lang/either";
+import * as DChrono from "@duplojs/lang/chrono";
+import type * as DPath from "@duplojs/lang/path";
+interface SetTimeParams {
+    accessTime: DChrono.TheDate;
+    modifiedTime: DChrono.TheDate;
+}
+export type SetTimeResult = FileSystemEither<DEither.Right<"set-time", void> | DEither.Left<"set-time-not-found", unknown> | DEither.Left<"set-time-permission-denied", unknown> | DEither.Left<"set-time-not-directory", unknown> | DEither.Left<"set-time-read-only", unknown> | DEither.Left<"set-time-invalid-argument", unknown> | DEither.Left<"set-time-error", unknown>>;
+declare module '../implementor' {
+    interface ServerFunction {
+        setTime(path: string & DPath.Path, params: SetTimeParams): Promise<SetTimeResult>;
+    }
+}
+export declare function setTime(params: SetTimeParams): (path: string & DPath.Path) => Promise<SetTimeResult>;
+export declare function setTime(path: string & DPath.Path, params: SetTimeParams): Promise<SetTimeResult>;
+export {};

package/dist/file/setTime.mjs

@@ -0,0 +1,36 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DEither from "@duplojs/lang/either";
+import * as DChrono from "@duplojs/lang/chrono";
+//#region scripts/file/setTime.ts
+function handleNodeSetTimeError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return DEither.left("file-system-set-time-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-set-time-permission-denied", error);
+		else if (error.code === "ENOTDIR") return DEither.left("file-system-set-time-not-directory", error);
+		else if (error.code === "EROFS") return DEither.left("file-system-set-time-read-only", error);
+		else if (error.code === "EINVAL") return DEither.left("file-system-set-time-invalid-argument", error);
+	}
+	return DEither.left("file-system-set-time-error", error);
+}
+function handleDenoSetTimeError(error) {
+	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-set-time-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-set-time-permission-denied", error);
+	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-set-time-not-directory", error);
+	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-set-time-invalid-argument", error);
+	return DEither.left("file-system-set-time-error", error);
+}
+const setTimeImplementation = implementFunction("setTime", {
+	NODE: async (path, { accessTime, modifiedTime }) => {
+		return (await nodeFileSystem.value).utimes(path, DChrono.toTimestamp(accessTime), DChrono.toTimestamp(modifiedTime)).then(() => DEither.right("file-system-set-time")).catch(handleNodeSetTimeError);
+	},
+	DENO: (path, { accessTime, modifiedTime }) => Deno.utime(path, DChrono.toTimestamp(accessTime), DChrono.toTimestamp(modifiedTime)).then(() => DEither.right("file-system-set-time")).catch(handleDenoSetTimeError)
+});
+function setTime(...args) {
+	if (args.length === 1) {
+		const [params] = args;
+		return (path) => setTimeImplementation(path, params);
+	}
+	return setTimeImplementation(...args);
+}
+//#endregion
+export { setTime };

package/dist/file/stat.cjs

@@ -0,0 +1,85 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_implementor = require("../implementor.cjs");
+let _duplojs_lang_common = require("@duplojs/lang/common");
+_duplojs_lang_common = require_runtime.__toESM(_duplojs_lang_common, 1);
+let _duplojs_lang_either = require("@duplojs/lang/either");
+_duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
+let _duplojs_lang_chrono = require("@duplojs/lang/chrono");
+_duplojs_lang_chrono = require_runtime.__toESM(_duplojs_lang_chrono, 1);
+//#region scripts/file/stat.ts
+function handleNodeStatError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-stat-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-stat-permission-denied", error);
+		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-stat-not-directory", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-stat-too-many-open-files", error);
+		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-stat-busy", error);
+	}
+	return _duplojs_lang_either.left("file-system-stat-error", error);
+}
+function handleDenoStatError(error) {
+	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-stat-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-stat-permission-denied", error);
+	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-stat-not-directory", error);
+	if (error instanceof Deno.errors.Busy) return _duplojs_lang_either.left("file-system-stat-busy", error);
+	return _duplojs_lang_either.left("file-system-stat-error", error);
+}
+function createStatInfoWithFsSource(source) {
+	return {
+		isFile: source.isFile(),
+		isDirectory: source.isDirectory(),
+		isSymlink: source.isSymbolicLink(),
+		sizeBytes: source.size,
+		modifiedAt: _duplojs_lang_chrono.isSafeTimestamp(source.mtime.getTime()) ? _duplojs_lang_chrono.createDateOrThrow(source.mtime) : null,
+		accessedAt: _duplojs_lang_chrono.isSafeTimestamp(source.atime.getTime()) ? _duplojs_lang_chrono.createDateOrThrow(source.atime) : null,
+		createdAt: _duplojs_lang_chrono.isSafeTimestamp(source.birthtime.getTime()) ? _duplojs_lang_chrono.createDateOrThrow(source.birthtime) : null,
+		changedAt: _duplojs_lang_chrono.isSafeTimestamp(source.ctime.getTime()) ? _duplojs_lang_chrono.createDateOrThrow(source.ctime) : null,
+		deviceId: source.dev,
+		inode: source.ino,
+		permissionsMode: source.mode,
+		hardLinkCount: source.nlink,
+		ownerUserId: source.uid,
+		ownerGroupId: source.gid,
+		specialDeviceId: source.rdev,
+		ioBlockSize: source.blksize,
+		allocatedBlockCount: source.blocks,
+		isBlockDevice: source.isBlockDevice(),
+		isCharacterDevice: source.isCharacterDevice(),
+		isFifo: source.isFIFO(),
+		isSocket: source.isSocket()
+	};
+}
+function createStatInfoWithDeno(source) {
+	return {
+		isFile: source.isFile,
+		isDirectory: source.isDirectory,
+		isSymlink: source.isSymlink,
+		sizeBytes: source.size,
+		modifiedAt: source.mtime && _duplojs_lang_chrono.isSafeTimestamp(source.mtime.getTime()) ? _duplojs_lang_chrono.createDateOrThrow(source.mtime) : null,
+		accessedAt: source.atime && _duplojs_lang_chrono.isSafeTimestamp(source.atime.getTime()) ? _duplojs_lang_chrono.createDateOrThrow(source.atime) : null,
+		createdAt: source.birthtime && _duplojs_lang_chrono.isSafeTimestamp(source.birthtime.getTime()) ? _duplojs_lang_chrono.createDateOrThrow(source.birthtime) : null,
+		changedAt: source.ctime && _duplojs_lang_chrono.isSafeTimestamp(source.ctime.getTime()) ? _duplojs_lang_chrono.createDateOrThrow(source.ctime) : null,
+		deviceId: source.dev,
+		inode: source.ino,
+		permissionsMode: source.mode,
+		hardLinkCount: source.nlink,
+		ownerUserId: source.uid,
+		ownerGroupId: source.gid,
+		specialDeviceId: source.rdev,
+		ioBlockSize: source.blksize,
+		allocatedBlockCount: source.blocks,
+		isBlockDevice: source.isBlockDevice,
+		isCharacterDevice: source.isCharDevice,
+		isFifo: source.isFifo,
+		isSocket: source.isSocket
+	};
+}
+const stat = require_implementor.implementFunction("stat", {
+	NODE: async (path) => {
+		return (await require_implementor.nodeFileSystem.value).stat(path).then(_duplojs_lang_common.innerPipe(createStatInfoWithFsSource, (value) => _duplojs_lang_either.right("file-system-stat", value))).catch(handleNodeStatError);
+	},
+	DENO: (path) => Deno.stat(path).then(_duplojs_lang_common.innerPipe(createStatInfoWithDeno, (value) => _duplojs_lang_either.right("file-system-stat", value))).catch(handleDenoStatError),
+	BUN: (path) => Bun.file(path).stat().then(_duplojs_lang_common.innerPipe(createStatInfoWithFsSource, (value) => _duplojs_lang_either.right("file-system-stat", value))).catch(handleNodeStatError)
+});
+//#endregion
+exports.stat = stat;

package/dist/file/stat.d.ts

@@ -0,0 +1,42 @@
+import { FileSystemEither } from './types';
+import type * as DPath from "@duplojs/lang/path";
+import * as DEither from "@duplojs/lang/either";
+import * as DChrono from "@duplojs/lang/chrono";
+export interface StatInfo {
+    /** Type of entry */
+    isFile: boolean;
+    isDirectory: boolean;
+    isSymlink: boolean;
+    /** Size in bytes */
+    sizeBytes: number;
+    /** Timestamps */
+    modifiedAt: DChrono.TheDate | null;
+    accessedAt: DChrono.TheDate | null;
+    createdAt: DChrono.TheDate | null;
+    changedAt: DChrono.TheDate | null;
+    /** Unix/FS identifiers */
+    deviceId: number;
+    inode: number | null;
+    permissionsMode: number | null;
+    hardLinkCount: number | null;
+    /** Ownership */
+    ownerUserId: number | null;
+    ownerGroupId: number | null;
+    /** Special device id (if file is a device) */
+    specialDeviceId: number | null;
+    /** FS allocation */
+    ioBlockSize: number | null;
+    allocatedBlockCount: number | null;
+    /** Special file kinds */
+    isBlockDevice: boolean | null;
+    isCharacterDevice: boolean | null;
+    isFifo: boolean | null;
+    isSocket: boolean | null;
+}
+export type StatResult = FileSystemEither<DEither.Right<"stat", StatInfo> | DEither.Left<"stat-not-found", unknown> | DEither.Left<"stat-permission-denied", unknown> | DEither.Left<"stat-not-directory", unknown> | DEither.Left<"stat-too-many-open-files", unknown> | DEither.Left<"stat-busy", unknown> | DEither.Left<"stat-error", unknown>>;
+declare module '../implementor' {
+    interface ServerFunction {
+        stat(path: string & DPath.Path): Promise<StatResult>;
+    }
+}
+export declare const stat: (path: string & DPath.Path) => Promise<StatResult>;

package/dist/file/stat.mjs

@@ -0,0 +1,81 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+import * as DChrono from "@duplojs/lang/chrono";
+//#region scripts/file/stat.ts
+function handleNodeStatError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return DEither.left("file-system-stat-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-stat-permission-denied", error);
+		else if (error.code === "ENOTDIR") return DEither.left("file-system-stat-not-directory", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-stat-too-many-open-files", error);
+		else if (error.code === "EBUSY") return DEither.left("file-system-stat-busy", error);
+	}
+	return DEither.left("file-system-stat-error", error);
+}
+function handleDenoStatError(error) {
+	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-stat-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-stat-permission-denied", error);
+	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-stat-not-directory", error);
+	if (error instanceof Deno.errors.Busy) return DEither.left("file-system-stat-busy", error);
+	return DEither.left("file-system-stat-error", error);
+}
+function createStatInfoWithFsSource(source) {
+	return {
+		isFile: source.isFile(),
+		isDirectory: source.isDirectory(),
+		isSymlink: source.isSymbolicLink(),
+		sizeBytes: source.size,
+		modifiedAt: DChrono.isSafeTimestamp(source.mtime.getTime()) ? DChrono.createDateOrThrow(source.mtime) : null,
+		accessedAt: DChrono.isSafeTimestamp(source.atime.getTime()) ? DChrono.createDateOrThrow(source.atime) : null,
+		createdAt: DChrono.isSafeTimestamp(source.birthtime.getTime()) ? DChrono.createDateOrThrow(source.birthtime) : null,
+		changedAt: DChrono.isSafeTimestamp(source.ctime.getTime()) ? DChrono.createDateOrThrow(source.ctime) : null,
+		deviceId: source.dev,
+		inode: source.ino,
+		permissionsMode: source.mode,
+		hardLinkCount: source.nlink,
+		ownerUserId: source.uid,
+		ownerGroupId: source.gid,
+		specialDeviceId: source.rdev,
+		ioBlockSize: source.blksize,
+		allocatedBlockCount: source.blocks,
+		isBlockDevice: source.isBlockDevice(),
+		isCharacterDevice: source.isCharacterDevice(),
+		isFifo: source.isFIFO(),
+		isSocket: source.isSocket()
+	};
+}
+function createStatInfoWithDeno(source) {
+	return {
+		isFile: source.isFile,
+		isDirectory: source.isDirectory,
+		isSymlink: source.isSymlink,
+		sizeBytes: source.size,
+		modifiedAt: source.mtime && DChrono.isSafeTimestamp(source.mtime.getTime()) ? DChrono.createDateOrThrow(source.mtime) : null,
+		accessedAt: source.atime && DChrono.isSafeTimestamp(source.atime.getTime()) ? DChrono.createDateOrThrow(source.atime) : null,
+		createdAt: source.birthtime && DChrono.isSafeTimestamp(source.birthtime.getTime()) ? DChrono.createDateOrThrow(source.birthtime) : null,
+		changedAt: source.ctime && DChrono.isSafeTimestamp(source.ctime.getTime()) ? DChrono.createDateOrThrow(source.ctime) : null,
+		deviceId: source.dev,
+		inode: source.ino,
+		permissionsMode: source.mode,
+		hardLinkCount: source.nlink,
+		ownerUserId: source.uid,
+		ownerGroupId: source.gid,
+		specialDeviceId: source.rdev,
+		ioBlockSize: source.blksize,
+		allocatedBlockCount: source.blocks,
+		isBlockDevice: source.isBlockDevice,
+		isCharacterDevice: source.isCharDevice,
+		isFifo: source.isFifo,
+		isSocket: source.isSocket
+	};
+}
+const stat = implementFunction("stat", {
+	NODE: async (path) => {
+		return (await nodeFileSystem.value).stat(path).then(DCommon.innerPipe(createStatInfoWithFsSource, (value) => DEither.right("file-system-stat", value))).catch(handleNodeStatError);
+	},
+	DENO: (path) => Deno.stat(path).then(DCommon.innerPipe(createStatInfoWithDeno, (value) => DEither.right("file-system-stat", value))).catch(handleDenoStatError),
+	BUN: (path) => Bun.file(path).stat().then(DCommon.innerPipe(createStatInfoWithFsSource, (value) => DEither.right("file-system-stat", value))).catch(handleNodeStatError)
+});
+//#endregion
+export { stat };

package/dist/file/symlink.cjs

@@ -0,0 +1,42 @@
+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/symlink.ts
+function handleNodeSymlinkError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-symlink-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-symlink-permission-denied", error);
+		else if (error.code === "EEXIST") return _duplojs_lang_either.left("file-system-symlink-already-exists", error);
+		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-symlink-not-directory", error);
+		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-symlink-read-only", error);
+		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-symlink-invalid-argument", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-symlink-too-many-open-files", error);
+		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-symlink-busy", error);
+	}
+	return _duplojs_lang_either.left("file-system-symlink-error", error);
+}
+function handleDenoSymlinkError(error) {
+	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-symlink-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-symlink-permission-denied", error);
+	if (error instanceof Deno.errors.AlreadyExists) return _duplojs_lang_either.left("file-system-symlink-already-exists", error);
+	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-symlink-not-directory", error);
+	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-symlink-invalid-argument", error);
+	if (error instanceof Deno.errors.Busy) return _duplojs_lang_either.left("file-system-symlink-busy", error);
+	return _duplojs_lang_either.left("file-system-symlink-error", error);
+}
+const symlinkImplementation = require_implementor.implementFunction("symlink", {
+	NODE: async (oldPath, newPath, params) => {
+		return (await require_implementor.nodeFileSystem.value).symlink(oldPath, newPath, params?.type).then(() => _duplojs_lang_either.right("file-system-symlink")).catch(handleNodeSymlinkError);
+	},
+	DENO: (oldPath, newPath, params) => Deno.symlink(oldPath, newPath, params).then(() => _duplojs_lang_either.right("file-system-symlink")).catch(handleDenoSymlinkError)
+});
+function symlink(...args) {
+	if (args.length === 1) {
+		const [newPath] = args;
+		return (oldPath) => symlinkImplementation(oldPath, newPath);
+	}
+	return symlinkImplementation(...args);
+}
+//#endregion
+exports.symlink = symlink;