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

package/dist/file/linkStat.mjs

@@ -0,0 +1,80 @@
+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/linkStat.ts
+function handleNodeLinkStatError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return DEither.left("file-system-link-stat-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-link-stat-permission-denied", error);
+		else if (error.code === "ENOTDIR") return DEither.left("file-system-link-stat-not-directory", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-link-stat-too-many-open-files", error);
+		else if (error.code === "EBUSY") return DEither.left("file-system-link-stat-busy", error);
+	}
+	return DEither.left("file-system-link-stat-error", error);
+}
+function handleDenoLinkStatError(error) {
+	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-link-stat-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-link-stat-permission-denied", error);
+	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-link-stat-not-directory", error);
+	if (error instanceof Deno.errors.Busy) return DEither.left("file-system-link-stat-busy", error);
+	return DEither.left("file-system-link-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 linkStat = implementFunction("linkStat", {
+	NODE: async (path) => {
+		return (await nodeFileSystem.value).lstat(path).then(DCommon.innerPipe(createStatInfoWithFsSource, (value) => DEither.right("file-system-link-stat", value))).catch(handleNodeLinkStatError);
+	},
+	DENO: (path) => Deno.lstat(path).then(DCommon.innerPipe(createStatInfoWithDeno, (value) => DEither.right("file-system-link-stat", value))).catch(handleDenoLinkStatError)
+});
+//#endregion
+export { linkStat };

package/dist/file/makeDirectory.cjs

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

package/dist/file/makeDirectory.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 MakeDirectoryParams {
+    recursive?: boolean;
+}
+export type MakeDirectoryResult = FileSystemEither<DEither.Right<"make-directory", void> | DEither.Left<"make-directory-not-found", unknown> | DEither.Left<"make-directory-permission-denied", unknown> | DEither.Left<"make-directory-already-exists", unknown> | DEither.Left<"make-directory-not-directory", unknown> | DEither.Left<"make-directory-no-space", unknown> | DEither.Left<"make-directory-read-only", unknown> | DEither.Left<"make-directory-invalid-argument", unknown> | DEither.Left<"make-directory-too-many-open-files", unknown> | DEither.Left<"make-directory-busy", unknown> | DEither.Left<"make-directory-error", unknown>>;
+declare module '../implementor' {
+    interface ServerFunction {
+        makeDirectory(path: string & DPath.Path, params?: MakeDirectoryParams): Promise<MakeDirectoryResult>;
+    }
+}
+export declare const makeDirectory: (path: string & DPath.Path, params?: MakeDirectoryParams) => Promise<MakeDirectoryResult>;
+export {};

package/dist/file/makeDirectory.mjs

@@ -0,0 +1,34 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/file/makeDirectory.ts
+function handleNodeMakeDirectoryError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return DEither.left("file-system-make-directory-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-make-directory-permission-denied", error);
+		else if (error.code === "EEXIST") return DEither.left("file-system-make-directory-already-exists", error);
+		else if (error.code === "ENOTDIR") return DEither.left("file-system-make-directory-not-directory", error);
+		else if (error.code === "ENOSPC") return DEither.left("file-system-make-directory-no-space", error);
+		else if (error.code === "EROFS") return DEither.left("file-system-make-directory-read-only", error);
+		else if (error.code === "EINVAL") return DEither.left("file-system-make-directory-invalid-argument", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-make-directory-too-many-open-files", error);
+		else if (error.code === "EBUSY") return DEither.left("file-system-make-directory-busy", error);
+	}
+	return DEither.left("file-system-make-directory-error", error);
+}
+function handleDenoMakeDirectoryError(error) {
+	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-make-directory-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-make-directory-permission-denied", error);
+	if (error instanceof Deno.errors.AlreadyExists) return DEither.left("file-system-make-directory-already-exists", error);
+	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-make-directory-not-directory", error);
+	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-make-directory-invalid-argument", error);
+	if (error instanceof Deno.errors.Busy) return DEither.left("file-system-make-directory-busy", error);
+	return DEither.left("file-system-make-directory-error", error);
+}
+const makeDirectory = implementFunction("makeDirectory", {
+	NODE: async (path, params) => {
+		return (await nodeFileSystem.value).mkdir(path, { recursive: params?.recursive }).then(() => DEither.right("file-system-make-directory")).catch(handleNodeMakeDirectoryError);
+	},
+	DENO: (path, params) => Deno.mkdir(path, { recursive: params?.recursive }).then(() => DEither.right("file-system-make-directory")).catch(handleDenoMakeDirectoryError)
+});
+//#endregion
+export { makeDirectory };

package/dist/file/makeTemporaryDirectory.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/makeTemporaryDirectory.ts
+function handleNodeMakeTemporaryDirectoryError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-make-temporary-directory-permission-denied", error);
+		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-make-temporary-directory-not-directory", error);
+		else if (error.code === "ENOSPC") return _duplojs_lang_either.left("file-system-make-temporary-directory-no-space", error);
+		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-make-temporary-directory-read-only", error);
+		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-make-temporary-directory-invalid-argument", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-make-temporary-directory-too-many-open-files", error);
+	}
+	return _duplojs_lang_either.left("file-system-make-temporary-directory-error", error);
+}
+function handleDenoMakeTemporaryDirectoryError(error) {
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-make-temporary-directory-permission-denied", error);
+	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-make-temporary-directory-not-directory", error);
+	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-make-temporary-directory-invalid-argument", error);
+	return _duplojs_lang_either.left("file-system-make-temporary-directory-error", error);
+}
+const makeTemporaryDirectory = require_implementor.implementFunction("makeTemporaryDirectory", {
+	NODE: async (prefix) => {
+		return (await require_implementor.nodeFileSystem.value).mkdtemp(prefix).then((value) => _duplojs_lang_either.right("file-system-make-temporary-directory", value)).catch(handleNodeMakeTemporaryDirectoryError);
+	},
+	DENO: (prefix) => Deno.makeTempDir({ prefix }).then((value) => _duplojs_lang_either.right("file-system-make-temporary-directory", value)).catch(handleDenoMakeTemporaryDirectoryError)
+});
+//#endregion
+exports.makeTemporaryDirectory = makeTemporaryDirectory;

package/dist/file/makeTemporaryDirectory.d.ts

@@ -0,0 +1,9 @@
+import { FileSystemEither } from './types';
+import * as DEither from "@duplojs/lang/either";
+export type MakeTemporaryDirectoryResult = FileSystemEither<DEither.Right<"make-temporary-directory", string> | DEither.Left<"make-temporary-directory-permission-denied", unknown> | DEither.Left<"make-temporary-directory-not-directory", unknown> | DEither.Left<"make-temporary-directory-no-space", unknown> | DEither.Left<"make-temporary-directory-read-only", unknown> | DEither.Left<"make-temporary-directory-invalid-argument", unknown> | DEither.Left<"make-temporary-directory-too-many-open-files", unknown> | DEither.Left<"make-temporary-directory-error", unknown>>;
+declare module '../implementor' {
+    interface ServerFunction {
+        makeTemporaryDirectory(prefix: string): Promise<MakeTemporaryDirectoryResult>;
+    }
+}
+export declare const makeTemporaryDirectory: (prefix: string) => Promise<MakeTemporaryDirectoryResult>;

package/dist/file/makeTemporaryDirectory.mjs

@@ -0,0 +1,28 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/file/makeTemporaryDirectory.ts
+function handleNodeMakeTemporaryDirectoryError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-make-temporary-directory-permission-denied", error);
+		else if (error.code === "ENOTDIR") return DEither.left("file-system-make-temporary-directory-not-directory", error);
+		else if (error.code === "ENOSPC") return DEither.left("file-system-make-temporary-directory-no-space", error);
+		else if (error.code === "EROFS") return DEither.left("file-system-make-temporary-directory-read-only", error);
+		else if (error.code === "EINVAL") return DEither.left("file-system-make-temporary-directory-invalid-argument", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-make-temporary-directory-too-many-open-files", error);
+	}
+	return DEither.left("file-system-make-temporary-directory-error", error);
+}
+function handleDenoMakeTemporaryDirectoryError(error) {
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-make-temporary-directory-permission-denied", error);
+	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-make-temporary-directory-not-directory", error);
+	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-make-temporary-directory-invalid-argument", error);
+	return DEither.left("file-system-make-temporary-directory-error", error);
+}
+const makeTemporaryDirectory = implementFunction("makeTemporaryDirectory", {
+	NODE: async (prefix) => {
+		return (await nodeFileSystem.value).mkdtemp(prefix).then((value) => DEither.right("file-system-make-temporary-directory", value)).catch(handleNodeMakeTemporaryDirectoryError);
+	},
+	DENO: (prefix) => Deno.makeTempDir({ prefix }).then((value) => DEither.right("file-system-make-temporary-directory", value)).catch(handleDenoMakeTemporaryDirectoryError)
+});
+//#endregion
+export { makeTemporaryDirectory };

package/dist/file/makeTemporaryFile.cjs

@@ -0,0 +1,45 @@
+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_path = require("@duplojs/lang/path");
+_duplojs_lang_path = require_runtime.__toESM(_duplojs_lang_path, 1);
+//#region scripts/file/makeTemporaryFile.ts
+function handleNodeMakeTemporaryFileError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-make-temporary-file-permission-denied", error);
+		else if (error.code === "EEXIST") return _duplojs_lang_either.left("file-system-make-temporary-file-already-exists", error);
+		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-make-temporary-file-not-directory", error);
+		else if (error.code === "ENOSPC") return _duplojs_lang_either.left("file-system-make-temporary-file-no-space", error);
+		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-make-temporary-file-read-only", error);
+		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-make-temporary-file-invalid-argument", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-make-temporary-file-too-many-open-files", error);
+	}
+	return _duplojs_lang_either.left("file-system-make-temporary-file-error", error);
+}
+function handleDenoMakeTemporaryFileError(error) {
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-make-temporary-file-permission-denied", error);
+	if (error instanceof Deno.errors.AlreadyExists) return _duplojs_lang_either.left("file-system-make-temporary-file-already-exists", error);
+	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-make-temporary-file-not-directory", error);
+	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-make-temporary-file-invalid-argument", error);
+	return _duplojs_lang_either.left("file-system-make-temporary-file-error", error);
+}
+const makeTemporaryFile = require_implementor.implementFunction("makeTemporaryFile", {
+	NODE: async (prefix, suffix) => {
+		const fs = await require_implementor.nodeFileSystem.value;
+		const os = await require_implementor.nodeOs.value;
+		const crypto = await require_implementor.nodeCrypto.value;
+		const tempPath = _duplojs_lang_common.forwardAsserts(os.tmpdir(), _duplojs_lang_path.is);
+		const fileName = _duplojs_lang_common.forwardAsserts(`${prefix}${crypto.randomUUID()}${suffix ?? ""}`, _duplojs_lang_path.isSegment);
+		const fileTemporaryPath = _duplojs_lang_path.resolveRelative([tempPath, fileName]);
+		return fs.open(fileTemporaryPath, "wx").then((fh) => fh.close()).then(() => _duplojs_lang_either.right("file-system-make-temporary-file", fileTemporaryPath)).catch(handleNodeMakeTemporaryFileError);
+	},
+	DENO: (prefix, suffix) => Deno.makeTempFile({
+		prefix,
+		suffix
+	}).then((value) => _duplojs_lang_either.right("file-system-make-temporary-file", value)).catch(handleDenoMakeTemporaryFileError)
+});
+//#endregion
+exports.makeTemporaryFile = makeTemporaryFile;

package/dist/file/makeTemporaryFile.d.ts

@@ -0,0 +1,10 @@
+import { FileSystemEither } from './types';
+import * as DPath from "@duplojs/lang/path";
+import * as DEither from "@duplojs/lang/either";
+export type MakeTemporaryFileResult = FileSystemEither<DEither.Right<"make-temporary-file", string> | DEither.Left<"make-temporary-file-permission-denied", unknown> | DEither.Left<"make-temporary-file-already-exists", unknown> | DEither.Left<"make-temporary-file-not-directory", unknown> | DEither.Left<"make-temporary-file-no-space", unknown> | DEither.Left<"make-temporary-file-read-only", unknown> | DEither.Left<"make-temporary-file-invalid-argument", unknown> | DEither.Left<"make-temporary-file-too-many-open-files", unknown> | DEither.Left<"make-temporary-file-error", unknown>>;
+declare module '../implementor' {
+    interface ServerFunction {
+        makeTemporaryFile(prefix: string & DPath.Segment, suffix?: string & DPath.Segment): Promise<MakeTemporaryFileResult>;
+    }
+}
+export declare const makeTemporaryFile: (prefix: string & DPath.Segment, suffix?: string & DPath.Segment) => Promise<MakeTemporaryFileResult>;

package/dist/file/makeTemporaryFile.mjs

@@ -0,0 +1,41 @@
+import { implementFunction, nodeCrypto, nodeFileSystem, nodeOs } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+import * as DPath from "@duplojs/lang/path";
+//#region scripts/file/makeTemporaryFile.ts
+function handleNodeMakeTemporaryFileError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-make-temporary-file-permission-denied", error);
+		else if (error.code === "EEXIST") return DEither.left("file-system-make-temporary-file-already-exists", error);
+		else if (error.code === "ENOTDIR") return DEither.left("file-system-make-temporary-file-not-directory", error);
+		else if (error.code === "ENOSPC") return DEither.left("file-system-make-temporary-file-no-space", error);
+		else if (error.code === "EROFS") return DEither.left("file-system-make-temporary-file-read-only", error);
+		else if (error.code === "EINVAL") return DEither.left("file-system-make-temporary-file-invalid-argument", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-make-temporary-file-too-many-open-files", error);
+	}
+	return DEither.left("file-system-make-temporary-file-error", error);
+}
+function handleDenoMakeTemporaryFileError(error) {
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-make-temporary-file-permission-denied", error);
+	if (error instanceof Deno.errors.AlreadyExists) return DEither.left("file-system-make-temporary-file-already-exists", error);
+	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-make-temporary-file-not-directory", error);
+	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-make-temporary-file-invalid-argument", error);
+	return DEither.left("file-system-make-temporary-file-error", error);
+}
+const makeTemporaryFile = implementFunction("makeTemporaryFile", {
+	NODE: async (prefix, suffix) => {
+		const fs = await nodeFileSystem.value;
+		const os = await nodeOs.value;
+		const crypto = await nodeCrypto.value;
+		const tempPath = DCommon.forwardAsserts(os.tmpdir(), DPath.is);
+		const fileName = DCommon.forwardAsserts(`${prefix}${crypto.randomUUID()}${suffix ?? ""}`, DPath.isSegment);
+		const fileTemporaryPath = DPath.resolveRelative([tempPath, fileName]);
+		return fs.open(fileTemporaryPath, "wx").then((fh) => fh.close()).then(() => DEither.right("file-system-make-temporary-file", fileTemporaryPath)).catch(handleNodeMakeTemporaryFileError);
+	},
+	DENO: (prefix, suffix) => Deno.makeTempFile({
+		prefix,
+		suffix
+	}).then((value) => DEither.right("file-system-make-temporary-file", value)).catch(handleDenoMakeTemporaryFileError)
+});
+//#endregion
+export { makeTemporaryFile };

package/dist/file/move.cjs

@@ -0,0 +1,45 @@
+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/move.ts
+function handleNodeMoveError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-move-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-move-permission-denied", error);
+		else if (error.code === "EEXIST") return _duplojs_lang_either.left("file-system-move-already-exists", error);
+		else if (error.code === "EISDIR") return _duplojs_lang_either.left("file-system-move-is-directory", error);
+		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-move-not-directory", error);
+		else if (error.code === "ENOTEMPTY") return _duplojs_lang_either.left("file-system-move-directory-not-empty", error);
+		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-move-read-only", error);
+		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-move-invalid-argument", error);
+		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-move-busy", error);
+		else if (error.code === "EXDEV") return _duplojs_lang_either.left("file-system-move-cross-device", error);
+	}
+	return _duplojs_lang_either.left("file-system-move-error", error);
+}
+function handleDenoMoveError(error) {
+	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-move-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-move-permission-denied", error);
+	if (error instanceof Deno.errors.AlreadyExists) return _duplojs_lang_either.left("file-system-move-already-exists", error);
+	if (error instanceof Deno.errors.IsADirectory) return _duplojs_lang_either.left("file-system-move-is-directory", error);
+	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-move-not-directory", error);
+	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-move-invalid-argument", error);
+	if (error instanceof Deno.errors.Busy) return _duplojs_lang_either.left("file-system-move-busy", error);
+	return _duplojs_lang_either.left("file-system-move-error", error);
+}
+const moveImplementation = require_implementor.implementFunction("move", {
+	NODE: async (fromPath, toPath) => {
+		return (await require_implementor.nodeFileSystem.value).rename(fromPath, toPath).then(() => _duplojs_lang_either.right("file-system-move")).catch(handleNodeMoveError);
+	},
+	DENO: (fromPath, toPath) => Deno.rename(fromPath, toPath).then(() => _duplojs_lang_either.right("file-system-move")).catch(handleDenoMoveError)
+});
+function move(...args) {
+	if (args.length === 1) {
+		const [toPath] = args;
+		return (fromPath) => moveImplementation(fromPath, toPath);
+	}
+	return moveImplementation(...args);
+}
+//#endregion
+exports.move = move;

package/dist/file/move.d.ts

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

package/dist/file/move.mjs

@@ -0,0 +1,43 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/file/move.ts
+function handleNodeMoveError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return DEither.left("file-system-move-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-move-permission-denied", error);
+		else if (error.code === "EEXIST") return DEither.left("file-system-move-already-exists", error);
+		else if (error.code === "EISDIR") return DEither.left("file-system-move-is-directory", error);
+		else if (error.code === "ENOTDIR") return DEither.left("file-system-move-not-directory", error);
+		else if (error.code === "ENOTEMPTY") return DEither.left("file-system-move-directory-not-empty", error);
+		else if (error.code === "EROFS") return DEither.left("file-system-move-read-only", error);
+		else if (error.code === "EINVAL") return DEither.left("file-system-move-invalid-argument", error);
+		else if (error.code === "EBUSY") return DEither.left("file-system-move-busy", error);
+		else if (error.code === "EXDEV") return DEither.left("file-system-move-cross-device", error);
+	}
+	return DEither.left("file-system-move-error", error);
+}
+function handleDenoMoveError(error) {
+	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-move-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-move-permission-denied", error);
+	if (error instanceof Deno.errors.AlreadyExists) return DEither.left("file-system-move-already-exists", error);
+	if (error instanceof Deno.errors.IsADirectory) return DEither.left("file-system-move-is-directory", error);
+	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-move-not-directory", error);
+	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-move-invalid-argument", error);
+	if (error instanceof Deno.errors.Busy) return DEither.left("file-system-move-busy", error);
+	return DEither.left("file-system-move-error", error);
+}
+const moveImplementation = implementFunction("move", {
+	NODE: async (fromPath, toPath) => {
+		return (await nodeFileSystem.value).rename(fromPath, toPath).then(() => DEither.right("file-system-move")).catch(handleNodeMoveError);
+	},
+	DENO: (fromPath, toPath) => Deno.rename(fromPath, toPath).then(() => DEither.right("file-system-move")).catch(handleDenoMoveError)
+});
+function move(...args) {
+	if (args.length === 1) {
+		const [toPath] = args;
+		return (fromPath) => moveImplementation(fromPath, toPath);
+	}
+	return moveImplementation(...args);
+}
+//#endregion
+export { move };

package/dist/file/readDirectory.cjs

@@ -0,0 +1,20 @@
+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/readDirectory.ts
+function handleNodeReadDirectoryError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-read-directory-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-read-directory-permission-denied", error);
+		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-read-directory-not-directory", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-read-directory-too-many-open-files", error);
+		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-read-directory-busy", error);
+	}
+	return _duplojs_lang_either.left("file-system-read-directory-error", error);
+}
+const readDirectory = require_implementor.implementFunction("readDirectory", { NODE: async (path, params) => {
+	return (await require_implementor.nodeFileSystem.value).readdir(path, { recursive: params?.recursive }).then((value) => _duplojs_lang_either.right("file-system-read-directory", value)).catch(handleNodeReadDirectoryError);
+} });
+//#endregion
+exports.readDirectory = readDirectory;

package/dist/file/readDirectory.d.ts

@@ -0,0 +1,14 @@
+import { FileSystemEither } from './types';
+import type * as DPath from "@duplojs/lang/path";
+import * as DEither from "@duplojs/lang/either";
+interface ReadDirectoryParams {
+    recursive?: boolean;
+}
+export type ReadDirectoryResult = FileSystemEither<DEither.Right<"read-directory", (string & DPath.Path)[]> | DEither.Left<"read-directory-not-found", unknown> | DEither.Left<"read-directory-permission-denied", unknown> | DEither.Left<"read-directory-not-directory", unknown> | DEither.Left<"read-directory-too-many-open-files", unknown> | DEither.Left<"read-directory-busy", unknown> | DEither.Left<"read-directory-error", unknown>>;
+declare module '../implementor' {
+    interface ServerFunction {
+        readDirectory(path: string & DPath.Path, params?: ReadDirectoryParams): Promise<ReadDirectoryResult>;
+    }
+}
+export declare const readDirectory: (path: string & DPath.Path, params?: ReadDirectoryParams) => Promise<ReadDirectoryResult>;
+export {};

package/dist/file/readDirectory.mjs

@@ -0,0 +1,18 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/file/readDirectory.ts
+function handleNodeReadDirectoryError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return DEither.left("file-system-read-directory-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-read-directory-permission-denied", error);
+		else if (error.code === "ENOTDIR") return DEither.left("file-system-read-directory-not-directory", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-read-directory-too-many-open-files", error);
+		else if (error.code === "EBUSY") return DEither.left("file-system-read-directory-busy", error);
+	}
+	return DEither.left("file-system-read-directory-error", error);
+}
+const readDirectory = implementFunction("readDirectory", { NODE: async (path, params) => {
+	return (await nodeFileSystem.value).readdir(path, { recursive: params?.recursive }).then((value) => DEither.right("file-system-read-directory", value)).catch(handleNodeReadDirectoryError);
+} });
+//#endregion
+export { readDirectory };

package/dist/file/readFile.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/readFile.ts
+function handleNodeReadFileError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-read-file-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-read-file-permission-denied", error);
+		else if (error.code === "EISDIR") return _duplojs_lang_either.left("file-system-read-file-is-directory", error);
+		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-read-file-not-directory", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-read-file-too-many-open-files", error);
+		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-read-file-busy", error);
+	}
+	return _duplojs_lang_either.left("file-system-read-file-error", error);
+}
+function handleDenoReadFileError(error) {
+	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-read-file-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-read-file-permission-denied", error);
+	if (error instanceof Deno.errors.IsADirectory) return _duplojs_lang_either.left("file-system-read-file-is-directory", error);
+	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-read-file-not-directory", error);
+	if (error instanceof Deno.errors.Busy) return _duplojs_lang_either.left("file-system-read-file-busy", error);
+	return _duplojs_lang_either.left("file-system-read-file-error", error);
+}
+const readFile = require_implementor.implementFunction("readFile", {
+	NODE: async (path) => {
+		return (await require_implementor.nodeFileSystem.value).readFile(path).then((value) => _duplojs_lang_either.right("file-system-read-file", value)).catch(handleNodeReadFileError);
+	},
+	DENO: (path) => Deno.readFile(path).then((value) => _duplojs_lang_either.right("file-system-read-file", value)).catch(handleDenoReadFileError),
+	BUN: (path) => Bun.file(path).bytes().then((value) => _duplojs_lang_either.right("file-system-read-file", value)).catch(handleNodeReadFileError)
+});
+//#endregion
+exports.readFile = readFile;

package/dist/file/readFile.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 ReadFileResult = FileSystemEither<DEither.Right<"read-file", Uint8Array> | DEither.Left<"read-file-not-found", unknown> | DEither.Left<"read-file-permission-denied", unknown> | DEither.Left<"read-file-is-directory", unknown> | DEither.Left<"read-file-not-directory", unknown> | DEither.Left<"read-file-too-many-open-files", unknown> | DEither.Left<"read-file-busy", unknown> | DEither.Left<"read-file-error", unknown>>;
+declare module '../implementor' {
+    interface ServerFunction {
+        readFile(path: string & DPath.Path): Promise<ReadFileResult>;
+    }
+}
+export declare const readFile: (path: string & DPath.Path) => Promise<ReadFileResult>;

package/dist/file/readFile.mjs

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