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

package/dist/file/setOwner.cjs

@@ -0,0 +1,53 @@
+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/setOwner.ts
+var SetOwnerErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-owner-not-found", Error) {};
+var SetOwnerErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-owner-permission-denied", Error) {};
+var SetOwnerErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-owner-not-directory", Error) {};
+var SetOwnerErrorReadOnly = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-owner-read-only", Error) {};
+var SetOwnerErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-owner-invalid-argument", Error) {};
+var SetOwnerError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-owner-error", Error) {};
+function handleNodeSetOwnerError(error) {
+	let setOwnerError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") setOwnerError = new SetOwnerErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") setOwnerError = new SetOwnerErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") setOwnerError = new SetOwnerErrorNotDirectory(error);
+		else if (error.code === "EROFS") setOwnerError = new SetOwnerErrorReadOnly(error);
+		else if (error.code === "EINVAL") setOwnerError = new SetOwnerErrorInvalidArgument(error);
+	}
+	if (setOwnerError === void 0) setOwnerError = new SetOwnerError(error);
+	return _duplojs_lang_either.left("file-system-set-owner-error", setOwnerError);
+}
+function handleDenoSetOwnerError(error) {
+	let setOwnerError = void 0;
+	if (error instanceof Deno.errors.NotFound) setOwnerError = new SetOwnerErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) setOwnerError = new SetOwnerErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.NotADirectory) setOwnerError = new SetOwnerErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) setOwnerError = new SetOwnerErrorInvalidArgument(error);
+	if (setOwnerError === void 0) setOwnerError = new SetOwnerError(error);
+	return _duplojs_lang_either.left("file-system-set-owner-error", setOwnerError);
+}
+const setOwnerImplementation = require_implementor.implementFunction("setOwner", {
+	NODE: async (path, { userId, groupId }) => 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.SetOwnerError = SetOwnerError;
+exports.SetOwnerErrorInvalidArgument = SetOwnerErrorInvalidArgument;
+exports.SetOwnerErrorNotDirectory = SetOwnerErrorNotDirectory;
+exports.SetOwnerErrorNotFound = SetOwnerErrorNotFound;
+exports.SetOwnerErrorPermissionDenied = SetOwnerErrorPermissionDenied;
+exports.SetOwnerErrorReadOnly = SetOwnerErrorReadOnly;
+exports.setOwner = setOwner;

package/dist/file/setOwner.d.ts

@@ -0,0 +1,35 @@
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+import type * as DPath from "@duplojs/lang/path";
+export interface SetOwnerParams {
+    userId: number;
+    groupId: number;
+}
+declare const SetOwnerErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-owner-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-owner-not-found", unknown>>, unknown>;
+export declare class SetOwnerErrorNotFound extends SetOwnerErrorNotFound_base {
+}
+declare const SetOwnerErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-owner-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-owner-permission-denied", unknown>>, unknown>;
+export declare class SetOwnerErrorPermissionDenied extends SetOwnerErrorPermissionDenied_base {
+}
+declare const SetOwnerErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-owner-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-owner-not-directory", unknown>>, unknown>;
+export declare class SetOwnerErrorNotDirectory extends SetOwnerErrorNotDirectory_base {
+}
+declare const SetOwnerErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-owner-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-owner-read-only", unknown>>, unknown>;
+export declare class SetOwnerErrorReadOnly extends SetOwnerErrorReadOnly_base {
+}
+declare const SetOwnerErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-owner-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-owner-invalid-argument", unknown>>, unknown>;
+export declare class SetOwnerErrorInvalidArgument extends SetOwnerErrorInvalidArgument_base {
+}
+declare const SetOwnerError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-owner-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-owner-error", unknown>>, unknown>;
+export declare class SetOwnerError extends SetOwnerError_base {
+}
+export type SetOwnerErrors = (SetOwnerErrorNotFound | SetOwnerErrorPermissionDenied | SetOwnerErrorNotDirectory | SetOwnerErrorReadOnly | SetOwnerErrorInvalidArgument | SetOwnerError);
+export type SetOwnerResult = (DEither.Right<"file-system-set-owner", void> | DEither.Left<"file-system-set-owner-error", SetOwnerErrors>);
+declare module '../implementor' {
+    interface ServerFunction {
+        setOwner(path: DPath.AnyPath, params: SetOwnerParams): Promise<SetOwnerResult>;
+    }
+}
+export declare function setOwner(params: SetOwnerParams): (path: DPath.AnyPath) => Promise<SetOwnerResult>;
+export declare function setOwner(path: DPath.AnyPath, params: SetOwnerParams): Promise<SetOwnerResult>;
+export {};

package/dist/file/setOwner.mjs

@@ -0,0 +1,44 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/file/setOwner.ts
+var SetOwnerErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-set-owner-not-found", Error) {};
+var SetOwnerErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-set-owner-permission-denied", Error) {};
+var SetOwnerErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-set-owner-not-directory", Error) {};
+var SetOwnerErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-set-owner-read-only", Error) {};
+var SetOwnerErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-set-owner-invalid-argument", Error) {};
+var SetOwnerError = class extends DCommon.DuploJSError.parentClass("file-system-set-owner-error", Error) {};
+function handleNodeSetOwnerError(error) {
+	let setOwnerError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") setOwnerError = new SetOwnerErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") setOwnerError = new SetOwnerErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") setOwnerError = new SetOwnerErrorNotDirectory(error);
+		else if (error.code === "EROFS") setOwnerError = new SetOwnerErrorReadOnly(error);
+		else if (error.code === "EINVAL") setOwnerError = new SetOwnerErrorInvalidArgument(error);
+	}
+	if (setOwnerError === void 0) setOwnerError = new SetOwnerError(error);
+	return DEither.left("file-system-set-owner-error", setOwnerError);
+}
+function handleDenoSetOwnerError(error) {
+	let setOwnerError = void 0;
+	if (error instanceof Deno.errors.NotFound) setOwnerError = new SetOwnerErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) setOwnerError = new SetOwnerErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.NotADirectory) setOwnerError = new SetOwnerErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) setOwnerError = new SetOwnerErrorInvalidArgument(error);
+	if (setOwnerError === void 0) setOwnerError = new SetOwnerError(error);
+	return DEither.left("file-system-set-owner-error", setOwnerError);
+}
+const setOwnerImplementation = implementFunction("setOwner", {
+	NODE: async (path, { userId, groupId }) => 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 { SetOwnerError, SetOwnerErrorInvalidArgument, SetOwnerErrorNotDirectory, SetOwnerErrorNotFound, SetOwnerErrorPermissionDenied, SetOwnerErrorReadOnly, setOwner };

package/dist/file/setTime.cjs

@@ -0,0 +1,55 @@
+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/setTime.ts
+var SetTimeErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-time-not-found", Error) {};
+var SetTimeErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-time-permission-denied", Error) {};
+var SetTimeErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-time-not-directory", Error) {};
+var SetTimeErrorReadOnly = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-time-read-only", Error) {};
+var SetTimeErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-time-invalid-argument", Error) {};
+var SetTimeError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-time-error", Error) {};
+function handleNodeSetTimeError(error) {
+	let setTimeError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") setTimeError = new SetTimeErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") setTimeError = new SetTimeErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") setTimeError = new SetTimeErrorNotDirectory(error);
+		else if (error.code === "EROFS") setTimeError = new SetTimeErrorReadOnly(error);
+		else if (error.code === "EINVAL") setTimeError = new SetTimeErrorInvalidArgument(error);
+	}
+	if (setTimeError === void 0) setTimeError = new SetTimeError(error);
+	return _duplojs_lang_either.left("file-system-set-time-error", setTimeError);
+}
+function handleDenoSetTimeError(error) {
+	let setTimeError = void 0;
+	if (error instanceof Deno.errors.NotFound) setTimeError = new SetTimeErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) setTimeError = new SetTimeErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.NotADirectory) setTimeError = new SetTimeErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) setTimeError = new SetTimeErrorInvalidArgument(error);
+	if (setTimeError === void 0) setTimeError = new SetTimeError(error);
+	return _duplojs_lang_either.left("file-system-set-time-error", setTimeError);
+}
+const setTimeImplementation = require_implementor.implementFunction("setTime", {
+	NODE: async (path, { accessTime, modifiedTime }) => 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.SetTimeError = SetTimeError;
+exports.SetTimeErrorInvalidArgument = SetTimeErrorInvalidArgument;
+exports.SetTimeErrorNotDirectory = SetTimeErrorNotDirectory;
+exports.SetTimeErrorNotFound = SetTimeErrorNotFound;
+exports.SetTimeErrorPermissionDenied = SetTimeErrorPermissionDenied;
+exports.SetTimeErrorReadOnly = SetTimeErrorReadOnly;
+exports.setTime = setTime;

package/dist/file/setTime.d.ts

@@ -0,0 +1,36 @@
+import * as DEither from "@duplojs/lang/either";
+import * as DChrono from "@duplojs/lang/chrono";
+import type * as DPath from "@duplojs/lang/path";
+import * as DCommon from "@duplojs/lang/common";
+interface SetTimeParams {
+    accessTime: DChrono.TheDate;
+    modifiedTime: DChrono.TheDate;
+}
+declare const SetTimeErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-time-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-time-not-found", unknown>>, unknown>;
+export declare class SetTimeErrorNotFound extends SetTimeErrorNotFound_base {
+}
+declare const SetTimeErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-time-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-time-permission-denied", unknown>>, unknown>;
+export declare class SetTimeErrorPermissionDenied extends SetTimeErrorPermissionDenied_base {
+}
+declare const SetTimeErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-time-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-time-not-directory", unknown>>, unknown>;
+export declare class SetTimeErrorNotDirectory extends SetTimeErrorNotDirectory_base {
+}
+declare const SetTimeErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-time-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-time-read-only", unknown>>, unknown>;
+export declare class SetTimeErrorReadOnly extends SetTimeErrorReadOnly_base {
+}
+declare const SetTimeErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-time-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-time-invalid-argument", unknown>>, unknown>;
+export declare class SetTimeErrorInvalidArgument extends SetTimeErrorInvalidArgument_base {
+}
+declare const SetTimeError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-time-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-time-error", unknown>>, unknown>;
+export declare class SetTimeError extends SetTimeError_base {
+}
+export type SetTimeErrors = (SetTimeErrorNotFound | SetTimeErrorPermissionDenied | SetTimeErrorNotDirectory | SetTimeErrorReadOnly | SetTimeErrorInvalidArgument | SetTimeError);
+export type SetTimeResult = (DEither.Right<"file-system-set-time", void> | DEither.Left<"file-system-set-time-error", SetTimeErrors>);
+declare module '../implementor' {
+    interface ServerFunction {
+        setTime(path: DPath.AnyPath, params: SetTimeParams): Promise<SetTimeResult>;
+    }
+}
+export declare function setTime(params: SetTimeParams): (path: DPath.AnyPath) => Promise<SetTimeResult>;
+export declare function setTime(path: DPath.AnyPath, params: SetTimeParams): Promise<SetTimeResult>;
+export {};

package/dist/file/setTime.mjs

@@ -0,0 +1,45 @@
+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/setTime.ts
+var SetTimeErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-set-time-not-found", Error) {};
+var SetTimeErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-set-time-permission-denied", Error) {};
+var SetTimeErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-set-time-not-directory", Error) {};
+var SetTimeErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-set-time-read-only", Error) {};
+var SetTimeErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-set-time-invalid-argument", Error) {};
+var SetTimeError = class extends DCommon.DuploJSError.parentClass("file-system-set-time-error", Error) {};
+function handleNodeSetTimeError(error) {
+	let setTimeError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") setTimeError = new SetTimeErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") setTimeError = new SetTimeErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") setTimeError = new SetTimeErrorNotDirectory(error);
+		else if (error.code === "EROFS") setTimeError = new SetTimeErrorReadOnly(error);
+		else if (error.code === "EINVAL") setTimeError = new SetTimeErrorInvalidArgument(error);
+	}
+	if (setTimeError === void 0) setTimeError = new SetTimeError(error);
+	return DEither.left("file-system-set-time-error", setTimeError);
+}
+function handleDenoSetTimeError(error) {
+	let setTimeError = void 0;
+	if (error instanceof Deno.errors.NotFound) setTimeError = new SetTimeErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) setTimeError = new SetTimeErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.NotADirectory) setTimeError = new SetTimeErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) setTimeError = new SetTimeErrorInvalidArgument(error);
+	if (setTimeError === void 0) setTimeError = new SetTimeError(error);
+	return DEither.left("file-system-set-time-error", setTimeError);
+}
+const setTimeImplementation = implementFunction("setTime", {
+	NODE: async (path, { accessTime, modifiedTime }) => 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 { SetTimeError, SetTimeErrorInvalidArgument, SetTimeErrorNotDirectory, SetTimeErrorNotFound, SetTimeErrorPermissionDenied, SetTimeErrorReadOnly, setTime };

package/dist/file/stat.cjs

@@ -0,0 +1,99 @@
+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
+var StatErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-stat-not-found", Error) {};
+var StatErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-stat-permission-denied", Error) {};
+var StatErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-stat-not-directory", Error) {};
+var StatErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-stat-too-many-open-files", Error) {};
+var StatErrorBusy = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-stat-busy", Error) {};
+var StatError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-stat-error", Error) {};
+function handleNodeStatError(error) {
+	let statError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") statError = new StatErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") statError = new StatErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") statError = new StatErrorNotDirectory(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") statError = new StatErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") statError = new StatErrorBusy(error);
+	}
+	if (statError === void 0) statError = new StatError(error);
+	return _duplojs_lang_either.left("file-system-stat-error", statError);
+}
+function handleDenoStatError(error) {
+	let statError = void 0;
+	if (error instanceof Deno.errors.NotFound) statError = new StatErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) statError = new StatErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.NotADirectory) statError = new StatErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.Busy) statError = new StatErrorBusy(error);
+	if (statError === void 0) statError = new StatError(error);
+	return _duplojs_lang_either.left("file-system-stat-error", statError);
+}
+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) => 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.StatError = StatError;
+exports.StatErrorBusy = StatErrorBusy;
+exports.StatErrorNotDirectory = StatErrorNotDirectory;
+exports.StatErrorNotFound = StatErrorNotFound;
+exports.StatErrorPermissionDenied = StatErrorPermissionDenied;
+exports.StatErrorTooManyOpenFiles = StatErrorTooManyOpenFiles;
+exports.stat = stat;

package/dist/file/stat.d.ts

@@ -0,0 +1,62 @@
+import * as DCommon from "@duplojs/lang/common";
+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;
+}
+declare const StatErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-stat-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-stat-not-found", unknown>>, unknown>;
+export declare class StatErrorNotFound extends StatErrorNotFound_base {
+}
+declare const StatErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-stat-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-stat-permission-denied", unknown>>, unknown>;
+export declare class StatErrorPermissionDenied extends StatErrorPermissionDenied_base {
+}
+declare const StatErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-stat-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-stat-not-directory", unknown>>, unknown>;
+export declare class StatErrorNotDirectory extends StatErrorNotDirectory_base {
+}
+declare const StatErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-stat-too-many-open-files", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-stat-too-many-open-files", unknown>>, unknown>;
+export declare class StatErrorTooManyOpenFiles extends StatErrorTooManyOpenFiles_base {
+}
+declare const StatErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-stat-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-stat-busy", unknown>>, unknown>;
+export declare class StatErrorBusy extends StatErrorBusy_base {
+}
+declare const StatError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-stat-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-stat-error", unknown>>, unknown>;
+export declare class StatError extends StatError_base {
+}
+export type StatErrors = (StatErrorNotFound | StatErrorPermissionDenied | StatErrorNotDirectory | StatErrorTooManyOpenFiles | StatErrorBusy | StatError);
+export type StatResult = (DEither.Right<"file-system-stat", StatInfo> | DEither.Left<"file-system-stat-error", StatErrors>);
+declare module '../implementor' {
+    interface ServerFunction {
+        stat(path: DPath.AnyPath): Promise<StatResult>;
+    }
+}
+export declare const stat: (path: DPath.AnyPath) => Promise<StatResult>;
+export {};

package/dist/file/stat.mjs

@@ -0,0 +1,89 @@
+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
+var StatErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-stat-not-found", Error) {};
+var StatErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-stat-permission-denied", Error) {};
+var StatErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-stat-not-directory", Error) {};
+var StatErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-stat-too-many-open-files", Error) {};
+var StatErrorBusy = class extends DCommon.DuploJSError.parentClass("file-system-stat-busy", Error) {};
+var StatError = class extends DCommon.DuploJSError.parentClass("file-system-stat-error", Error) {};
+function handleNodeStatError(error) {
+	let statError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") statError = new StatErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") statError = new StatErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") statError = new StatErrorNotDirectory(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") statError = new StatErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") statError = new StatErrorBusy(error);
+	}
+	if (statError === void 0) statError = new StatError(error);
+	return DEither.left("file-system-stat-error", statError);
+}
+function handleDenoStatError(error) {
+	let statError = void 0;
+	if (error instanceof Deno.errors.NotFound) statError = new StatErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) statError = new StatErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.NotADirectory) statError = new StatErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.Busy) statError = new StatErrorBusy(error);
+	if (statError === void 0) statError = new StatError(error);
+	return DEither.left("file-system-stat-error", statError);
+}
+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) => 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 { StatError, StatErrorBusy, StatErrorNotDirectory, StatErrorNotFound, StatErrorPermissionDenied, StatErrorTooManyOpenFiles, stat };

package/dist/file/symlink.cjs

@@ -0,0 +1,64 @@
+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/symlink.ts
+var SymlinkErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-symlink-not-found", Error) {};
+var SymlinkErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-symlink-permission-denied", Error) {};
+var SymlinkErrorAlreadyExists = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-symlink-already-exists", Error) {};
+var SymlinkErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-symlink-not-directory", Error) {};
+var SymlinkErrorReadOnly = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-symlink-read-only", Error) {};
+var SymlinkErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-symlink-invalid-argument", Error) {};
+var SymlinkErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-symlink-too-many-open-files", Error) {};
+var SymlinkErrorBusy = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-symlink-busy", Error) {};
+var SymlinkError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-symlink-error", Error) {};
+function handleNodeSymlinkError(error) {
+	let symlinkError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") symlinkError = new SymlinkErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") symlinkError = new SymlinkErrorPermissionDenied(error);
+		else if (error.code === "EEXIST") symlinkError = new SymlinkErrorAlreadyExists(error);
+		else if (error.code === "ENOTDIR") symlinkError = new SymlinkErrorNotDirectory(error);
+		else if (error.code === "EROFS") symlinkError = new SymlinkErrorReadOnly(error);
+		else if (error.code === "EINVAL") symlinkError = new SymlinkErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") symlinkError = new SymlinkErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") symlinkError = new SymlinkErrorBusy(error);
+	}
+	if (symlinkError === void 0) symlinkError = new SymlinkError(error);
+	return _duplojs_lang_either.left("file-system-symlink-error", symlinkError);
+}
+function handleDenoSymlinkError(error) {
+	let symlinkError = void 0;
+	if (error instanceof Deno.errors.NotFound) symlinkError = new SymlinkErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) symlinkError = new SymlinkErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.AlreadyExists) symlinkError = new SymlinkErrorAlreadyExists(error);
+	else if (error instanceof Deno.errors.NotADirectory) symlinkError = new SymlinkErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) symlinkError = new SymlinkErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) symlinkError = new SymlinkErrorBusy(error);
+	if (symlinkError === void 0) symlinkError = new SymlinkError(error);
+	return _duplojs_lang_either.left("file-system-symlink-error", symlinkError);
+}
+const symlinkImplementation = require_implementor.implementFunction("symlink", {
+	NODE: async (oldPath, newPath, params) => 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.SymlinkError = SymlinkError;
+exports.SymlinkErrorAlreadyExists = SymlinkErrorAlreadyExists;
+exports.SymlinkErrorBusy = SymlinkErrorBusy;
+exports.SymlinkErrorInvalidArgument = SymlinkErrorInvalidArgument;
+exports.SymlinkErrorNotDirectory = SymlinkErrorNotDirectory;
+exports.SymlinkErrorNotFound = SymlinkErrorNotFound;
+exports.SymlinkErrorPermissionDenied = SymlinkErrorPermissionDenied;
+exports.SymlinkErrorReadOnly = SymlinkErrorReadOnly;
+exports.SymlinkErrorTooManyOpenFiles = SymlinkErrorTooManyOpenFiles;
+exports.symlink = symlink;