@duplojs/server 0.1.0-beta.2 → 0.1.0-beta.3

package/dist/file/stat.mjs

@@ -3,22 +3,32 @@ 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) {
-	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);
+	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);
 	}
-	return DEither.left("file-system-stat-error", error);
+	if (statError === void 0) statError = new StatError(error);
+	return DEither.left("file-system-stat-error", statError);
 }
 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);
+	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 {
@@ -71,9 +81,7 @@ function createStatInfoWithDeno(source) {
 	};
 }
 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);
-	},
+	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)
 });

package/dist/file/symlink.cjs

@@ -1,34 +1,47 @@
 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) {
-	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);
+	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);
 	}
-	return _duplojs_lang_either.left("file-system-symlink-error", error);
+	if (symlinkError === void 0) symlinkError = new SymlinkError(error);
+	return _duplojs_lang_either.left("file-system-symlink-error", symlinkError);
 }
 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);
+	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) => {
-		return (await require_implementor.nodeFileSystem.value).symlink(oldPath, newPath, params?.type).then(() => _duplojs_lang_either.right("file-system-symlink")).catch(handleNodeSymlinkError);
-	},
+	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) {

package/dist/file/symlink.d.ts

@@ -1,4 +1,4 @@
-import { FileSystemEither } from './types';
+import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 import type * as DPath from "@duplojs/lang/path";
 export interface SymlinkParams {
@@ -9,7 +9,35 @@ export interface SymlinkParams {
      */
     type: "file" | "dir" | "junction";
 }
-export type SymlinkResult = FileSystemEither<DEither.Right<"symlink", void> | DEither.Left<"symlink-not-found", unknown> | DEither.Left<"symlink-permission-denied", unknown> | DEither.Left<"symlink-already-exists", unknown> | DEither.Left<"symlink-not-directory", unknown> | DEither.Left<"symlink-read-only", unknown> | DEither.Left<"symlink-invalid-argument", unknown> | DEither.Left<"symlink-too-many-open-files", unknown> | DEither.Left<"symlink-busy", unknown> | DEither.Left<"symlink-error", unknown>>;
+declare const SymlinkErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-symlink-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-symlink-not-found", unknown>>, unknown>;
+declare class SymlinkErrorNotFound extends SymlinkErrorNotFound_base {
+}
+declare const SymlinkErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-symlink-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-symlink-permission-denied", unknown>>, unknown>;
+declare class SymlinkErrorPermissionDenied extends SymlinkErrorPermissionDenied_base {
+}
+declare const SymlinkErrorAlreadyExists_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-symlink-already-exists", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-symlink-already-exists", unknown>>, unknown>;
+declare class SymlinkErrorAlreadyExists extends SymlinkErrorAlreadyExists_base {
+}
+declare const SymlinkErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-symlink-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-symlink-not-directory", unknown>>, unknown>;
+declare class SymlinkErrorNotDirectory extends SymlinkErrorNotDirectory_base {
+}
+declare const SymlinkErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-symlink-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-symlink-read-only", unknown>>, unknown>;
+declare class SymlinkErrorReadOnly extends SymlinkErrorReadOnly_base {
+}
+declare const SymlinkErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-symlink-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-symlink-invalid-argument", unknown>>, unknown>;
+declare class SymlinkErrorInvalidArgument extends SymlinkErrorInvalidArgument_base {
+}
+declare const SymlinkErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-symlink-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-symlink-too-many-open-files", unknown>>, unknown>;
+declare class SymlinkErrorTooManyOpenFiles extends SymlinkErrorTooManyOpenFiles_base {
+}
+declare const SymlinkErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-symlink-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-symlink-busy", unknown>>, unknown>;
+declare class SymlinkErrorBusy extends SymlinkErrorBusy_base {
+}
+declare const SymlinkError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-symlink-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-symlink-error", unknown>>, unknown>;
+declare class SymlinkError extends SymlinkError_base {
+}
+export type SymlinkErrors = (SymlinkErrorNotFound | SymlinkErrorPermissionDenied | SymlinkErrorAlreadyExists | SymlinkErrorNotDirectory | SymlinkErrorReadOnly | SymlinkErrorInvalidArgument | SymlinkErrorTooManyOpenFiles | SymlinkErrorBusy | SymlinkError);
+export type SymlinkResult = (DEither.Right<"file-system-symlink", void> | DEither.Left<"file-system-symlink-error", SymlinkErrors>);
 declare module '../implementor' {
     interface ServerFunction {
         symlink(oldPath: string & DPath.Path, newPath: string & DPath.Path, params?: SymlinkParams): Promise<SymlinkResult>;
@@ -17,3 +45,4 @@ declare module '../implementor' {
 }
 export declare function symlink(newPath: string & DPath.Path): (oldPath: string & DPath.Path) => Promise<SymlinkResult>;
 export declare function symlink(oldPath: string & DPath.Path, newPath: string & DPath.Path, params?: SymlinkParams): Promise<SymlinkResult>;
+export {};

package/dist/file/symlink.mjs

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

package/dist/file/truncate.cjs

@@ -5,33 +5,45 @@ _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/truncate.ts
+var TruncateErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-truncate-not-found", Error) {};
+var TruncateErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-truncate-permission-denied", Error) {};
+var TruncateErrorIsDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-truncate-is-directory", Error) {};
+var TruncateErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-truncate-not-directory", Error) {};
+var TruncateErrorNoSpace = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-truncate-no-space", Error) {};
+var TruncateErrorReadOnly = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-truncate-read-only", Error) {};
+var TruncateErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-truncate-invalid-argument", Error) {};
+var TruncateErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-truncate-too-many-open-files", Error) {};
+var TruncateErrorBusy = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-truncate-busy", Error) {};
+var TruncateError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-truncate-error", Error) {};
 function handleNodeTruncateError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-truncate-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-truncate-permission-denied", error);
-		else if (error.code === "EISDIR") return _duplojs_lang_either.left("file-system-truncate-is-directory", error);
-		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-truncate-not-directory", error);
-		else if (error.code === "ENOSPC") return _duplojs_lang_either.left("file-system-truncate-no-space", error);
-		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-truncate-read-only", error);
-		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-truncate-invalid-argument", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-truncate-too-many-open-files", error);
-		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-truncate-busy", error);
+	let truncateError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") truncateError = new TruncateErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") truncateError = new TruncateErrorPermissionDenied(error);
+		else if (error.code === "EISDIR") truncateError = new TruncateErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") truncateError = new TruncateErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") truncateError = new TruncateErrorNoSpace(error);
+		else if (error.code === "EROFS") truncateError = new TruncateErrorReadOnly(error);
+		else if (error.code === "EINVAL") truncateError = new TruncateErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") truncateError = new TruncateErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") truncateError = new TruncateErrorBusy(error);
 	}
-	return _duplojs_lang_either.left("file-system-truncate-error", error);
+	if (truncateError === void 0) truncateError = new TruncateError(error);
+	return _duplojs_lang_either.left("file-system-truncate-error", truncateError);
 }
 function handleDenoTruncateError(error) {
-	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-truncate-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-truncate-permission-denied", error);
-	if (error instanceof Deno.errors.IsADirectory) return _duplojs_lang_either.left("file-system-truncate-is-directory", error);
-	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-truncate-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-truncate-invalid-argument", error);
-	if (error instanceof Deno.errors.Busy) return _duplojs_lang_either.left("file-system-truncate-busy", error);
-	return _duplojs_lang_either.left("file-system-truncate-error", error);
+	let truncateError = void 0;
+	if (error instanceof Deno.errors.NotFound) truncateError = new TruncateErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) truncateError = new TruncateErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.IsADirectory) truncateError = new TruncateErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) truncateError = new TruncateErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) truncateError = new TruncateErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) truncateError = new TruncateErrorBusy(error);
+	if (truncateError === void 0) truncateError = new TruncateError(error);
+	return _duplojs_lang_either.left("file-system-truncate-error", truncateError);
 }
 const truncate = require_implementor.implementFunction("truncate", {
-	NODE: async (path, size) => {
-		return (await require_implementor.nodeFileSystem.value).truncate(path, size).then(() => _duplojs_lang_either.right("file-system-truncate")).catch(handleNodeTruncateError);
-	},
+	NODE: async (path, size) => require_implementor.nodeFileSystem.value.truncate(path, size).then(() => _duplojs_lang_either.right("file-system-truncate")).catch(handleNodeTruncateError),
 	DENO: (path, size) => _duplojs_lang_common.pipe(path, _duplojs_lang_common.when(_duplojs_lang_common.instanceOf(URL), ({ pathname }) => decodeURIComponent(pathname)), (stringPath) => Deno.truncate(stringPath, size).then(() => _duplojs_lang_either.right("file-system-truncate")).catch(handleDenoTruncateError))
 });
 //#endregion

package/dist/file/truncate.d.ts

@@ -1,10 +1,42 @@
-import { FileSystemEither } from './types';
+import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 import type * as DPath from "@duplojs/lang/path";
-export type TruncateResult = FileSystemEither<DEither.Right<"truncate", void> | DEither.Left<"truncate-not-found", unknown> | DEither.Left<"truncate-permission-denied", unknown> | DEither.Left<"truncate-is-directory", unknown> | DEither.Left<"truncate-not-directory", unknown> | DEither.Left<"truncate-no-space", unknown> | DEither.Left<"truncate-read-only", unknown> | DEither.Left<"truncate-invalid-argument", unknown> | DEither.Left<"truncate-too-many-open-files", unknown> | DEither.Left<"truncate-busy", unknown> | DEither.Left<"truncate-error", unknown>>;
+declare const TruncateErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-truncate-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-truncate-not-found", unknown>>, unknown>;
+declare class TruncateErrorNotFound extends TruncateErrorNotFound_base {
+}
+declare const TruncateErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-truncate-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-truncate-permission-denied", unknown>>, unknown>;
+declare class TruncateErrorPermissionDenied extends TruncateErrorPermissionDenied_base {
+}
+declare const TruncateErrorIsDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-truncate-is-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-truncate-is-directory", unknown>>, unknown>;
+declare class TruncateErrorIsDirectory extends TruncateErrorIsDirectory_base {
+}
+declare const TruncateErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-truncate-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-truncate-not-directory", unknown>>, unknown>;
+declare class TruncateErrorNotDirectory extends TruncateErrorNotDirectory_base {
+}
+declare const TruncateErrorNoSpace_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-truncate-no-space", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-truncate-no-space", unknown>>, unknown>;
+declare class TruncateErrorNoSpace extends TruncateErrorNoSpace_base {
+}
+declare const TruncateErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-truncate-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-truncate-read-only", unknown>>, unknown>;
+declare class TruncateErrorReadOnly extends TruncateErrorReadOnly_base {
+}
+declare const TruncateErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-truncate-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-truncate-invalid-argument", unknown>>, unknown>;
+declare class TruncateErrorInvalidArgument extends TruncateErrorInvalidArgument_base {
+}
+declare const TruncateErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-truncate-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-truncate-too-many-open-files", unknown>>, unknown>;
+declare class TruncateErrorTooManyOpenFiles extends TruncateErrorTooManyOpenFiles_base {
+}
+declare const TruncateErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-truncate-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-truncate-busy", unknown>>, unknown>;
+declare class TruncateErrorBusy extends TruncateErrorBusy_base {
+}
+declare const TruncateError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-truncate-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-truncate-error", unknown>>, unknown>;
+declare class TruncateError extends TruncateError_base {
+}
+export type TruncateErrors = (TruncateErrorNotFound | TruncateErrorPermissionDenied | TruncateErrorIsDirectory | TruncateErrorNotDirectory | TruncateErrorNoSpace | TruncateErrorReadOnly | TruncateErrorInvalidArgument | TruncateErrorTooManyOpenFiles | TruncateErrorBusy | TruncateError);
+export type TruncateResult = (DEither.Right<"file-system-truncate", void> | DEither.Left<"file-system-truncate-error", TruncateErrors>);
 declare module '../implementor' {
     interface ServerFunction {
         truncate(path: string & DPath.Path, size?: number): Promise<TruncateResult>;
     }
 }
 export declare const truncate: (path: string & DPath.Path, size?: number) => Promise<TruncateResult>;
+export {};

package/dist/file/truncate.mjs

@@ -2,33 +2,45 @@ import { implementFunction, nodeFileSystem } from "../implementor.mjs";
 import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 //#region scripts/file/truncate.ts
+var TruncateErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-truncate-not-found", Error) {};
+var TruncateErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-truncate-permission-denied", Error) {};
+var TruncateErrorIsDirectory = class extends DCommon.DuploJSError.parentClass("file-system-truncate-is-directory", Error) {};
+var TruncateErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-truncate-not-directory", Error) {};
+var TruncateErrorNoSpace = class extends DCommon.DuploJSError.parentClass("file-system-truncate-no-space", Error) {};
+var TruncateErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-truncate-read-only", Error) {};
+var TruncateErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-truncate-invalid-argument", Error) {};
+var TruncateErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-truncate-too-many-open-files", Error) {};
+var TruncateErrorBusy = class extends DCommon.DuploJSError.parentClass("file-system-truncate-busy", Error) {};
+var TruncateError = class extends DCommon.DuploJSError.parentClass("file-system-truncate-error", Error) {};
 function handleNodeTruncateError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return DEither.left("file-system-truncate-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-truncate-permission-denied", error);
-		else if (error.code === "EISDIR") return DEither.left("file-system-truncate-is-directory", error);
-		else if (error.code === "ENOTDIR") return DEither.left("file-system-truncate-not-directory", error);
-		else if (error.code === "ENOSPC") return DEither.left("file-system-truncate-no-space", error);
-		else if (error.code === "EROFS") return DEither.left("file-system-truncate-read-only", error);
-		else if (error.code === "EINVAL") return DEither.left("file-system-truncate-invalid-argument", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-truncate-too-many-open-files", error);
-		else if (error.code === "EBUSY") return DEither.left("file-system-truncate-busy", error);
+	let truncateError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") truncateError = new TruncateErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") truncateError = new TruncateErrorPermissionDenied(error);
+		else if (error.code === "EISDIR") truncateError = new TruncateErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") truncateError = new TruncateErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") truncateError = new TruncateErrorNoSpace(error);
+		else if (error.code === "EROFS") truncateError = new TruncateErrorReadOnly(error);
+		else if (error.code === "EINVAL") truncateError = new TruncateErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") truncateError = new TruncateErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") truncateError = new TruncateErrorBusy(error);
 	}
-	return DEither.left("file-system-truncate-error", error);
+	if (truncateError === void 0) truncateError = new TruncateError(error);
+	return DEither.left("file-system-truncate-error", truncateError);
 }
 function handleDenoTruncateError(error) {
-	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-truncate-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-truncate-permission-denied", error);
-	if (error instanceof Deno.errors.IsADirectory) return DEither.left("file-system-truncate-is-directory", error);
-	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-truncate-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-truncate-invalid-argument", error);
-	if (error instanceof Deno.errors.Busy) return DEither.left("file-system-truncate-busy", error);
-	return DEither.left("file-system-truncate-error", error);
+	let truncateError = void 0;
+	if (error instanceof Deno.errors.NotFound) truncateError = new TruncateErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) truncateError = new TruncateErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.IsADirectory) truncateError = new TruncateErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) truncateError = new TruncateErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) truncateError = new TruncateErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) truncateError = new TruncateErrorBusy(error);
+	if (truncateError === void 0) truncateError = new TruncateError(error);
+	return DEither.left("file-system-truncate-error", truncateError);
 }
 const truncate = implementFunction("truncate", {
-	NODE: async (path, size) => {
-		return (await nodeFileSystem.value).truncate(path, size).then(() => DEither.right("file-system-truncate")).catch(handleNodeTruncateError);
-	},
+	NODE: async (path, size) => nodeFileSystem.value.truncate(path, size).then(() => DEither.right("file-system-truncate")).catch(handleNodeTruncateError),
 	DENO: (path, size) => DCommon.pipe(path, DCommon.when(DCommon.instanceOf(URL), ({ pathname }) => decodeURIComponent(pathname)), (stringPath) => Deno.truncate(stringPath, size).then(() => DEither.right("file-system-truncate")).catch(handleDenoTruncateError))
 });
 //#endregion

package/dist/file/unknownEntryInterface.cjs

@@ -31,6 +31,8 @@ function createUnknownEntryInterface(path) {
 function isUnknownEntryInterface(input) {
 	return unknownInterfaceKind.has(input);
 }
+const isUnknownEntryInterfaceFromUnknown = isUnknownEntryInterface;
 //#endregion
 exports.createUnknownEntryInterface = createUnknownEntryInterface;
 exports.isUnknownEntryInterface = isUnknownEntryInterface;
+exports.isUnknownEntryInterfaceFromUnknown = isUnknownEntryInterfaceFromUnknown;

package/dist/file/unknownEntryInterface.d.ts

@@ -3,13 +3,15 @@ import { ExistsResult } from './exists';
 import type * as DKind from "@duplojs/lang/kind";
 import * as DPath from "@duplojs/lang/path";
 declare const unknownInterfaceKind: DKind.Handler<DKind.Definition<"@DuplojsServer/unknownInterface", unknown>>;
-export interface UnknownEntryInterface extends DKind.Kind<typeof unknownInterfaceKind> {
-    path: string & DPath.Path;
-    getName(): (string & DPath.Segment) | null;
+export type EntryPath = (string & (DPath.Path | DPath.Absolute | DPath.Segment));
+export interface UnknownEntryInterface<GenericPath extends EntryPath = EntryPath> extends DKind.Kind<typeof unknownInterfaceKind> {
+    path: GenericPath & DPath.Path;
+    getName(): (string & DPath.Segment & DPath.Path) | null;
     getParentPath(): (string & DPath.Path) | null;
     stat(): Promise<StatResult>;
     exist(): Promise<ExistsResult>;
 }
-export declare function createUnknownEntryInterface(path: string & DPath.Path): UnknownEntryInterface;
-export declare function isUnknownEntryInterface(input: unknown): input is UnknownEntryInterface;
+export declare function createUnknownEntryInterface<GenericPath extends EntryPath = EntryPath>(path: GenericPath): UnknownEntryInterface<GenericPath>;
+export declare function isUnknownEntryInterface<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, UnknownEntryInterface>;
+export declare const isUnknownEntryInterfaceFromUnknown: (input: unknown) => input is UnknownEntryInterface;
 export {};

package/dist/file/unknownEntryInterface.mjs

@@ -29,5 +29,6 @@ function createUnknownEntryInterface(path) {
 function isUnknownEntryInterface(input) {
 	return unknownInterfaceKind.has(input);
 }
+const isUnknownEntryInterfaceFromUnknown = isUnknownEntryInterface;
 //#endregion
-export { createUnknownEntryInterface, isUnknownEntryInterface };
+export { createUnknownEntryInterface, isUnknownEntryInterface, isUnknownEntryInterfaceFromUnknown };

package/dist/file/walkDirectory.cjs

@@ -1,34 +1,47 @@
 const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
 const require_implementor = require("../implementor.cjs");
+const require_getCurrentWorkDirectoryOrThrow = require("../common/getCurrentWorkDirectoryOrThrow.cjs");
 const require_fileInterface = require("./fileInterface.cjs");
 const require_unknownEntryInterface = require("./unknownEntryInterface.cjs");
 const require_folderInterface = require("./folderInterface.cjs");
 let _duplojs_lang_common = require("@duplojs/lang/common");
 _duplojs_lang_common = require_runtime.__toESM(_duplojs_lang_common, 1);
+let _duplojs_lang_pattern = require("@duplojs/lang/pattern");
+_duplojs_lang_pattern = require_runtime.__toESM(_duplojs_lang_pattern, 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);
-let _duplojs_lang_pattern = require("@duplojs/lang/pattern");
-_duplojs_lang_pattern = require_runtime.__toESM(_duplojs_lang_pattern, 1);
 let _duplojs_lang_generator = require("@duplojs/lang/generator");
 _duplojs_lang_generator = require_runtime.__toESM(_duplojs_lang_generator, 1);
 //#region scripts/file/walkDirectory.ts
+var WalkDirectoryErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-walk-directory-not-found", Error) {};
+var WalkDirectoryErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-walk-directory-permission-denied", Error) {};
+var WalkDirectoryErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-walk-directory-not-directory", Error) {};
+var WalkDirectoryErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-walk-directory-too-many-open-files", Error) {};
+var WalkDirectoryErrorBusy = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-walk-directory-busy", Error) {};
+var WalkDirectoryError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-walk-directory-error", Error) {};
 function handleNodeWalkDirectoryError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-walk-directory-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-walk-directory-permission-denied", error);
-		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-walk-directory-not-directory", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-walk-directory-too-many-open-files", error);
-		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-walk-directory-busy", error);
+	let walkDirectoryError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") walkDirectoryError = new WalkDirectoryErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") walkDirectoryError = new WalkDirectoryErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") walkDirectoryError = new WalkDirectoryErrorNotDirectory(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") walkDirectoryError = new WalkDirectoryErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") walkDirectoryError = new WalkDirectoryErrorBusy(error);
 	}
-	return _duplojs_lang_either.left("file-system-walk-directory-error", error);
+	if (walkDirectoryError === void 0) walkDirectoryError = new WalkDirectoryError(error);
+	return _duplojs_lang_either.left("file-system-walk-directory-error", walkDirectoryError);
 }
-const walkDirectory = require_implementor.implementFunction("walkDirectory", { NODE: async (path, params) => {
-	return (await require_implementor.nodeFileSystem.value).readdir(path, {
-		recursive: params?.recursive ?? false,
-		withFileTypes: true
-	}).then(_duplojs_lang_common.innerPipe(_duplojs_lang_generator.map(_duplojs_lang_common.innerPipe(_duplojs_lang_pattern.when((dirent) => dirent.isFile(), ({ parentPath, name }) => require_fileInterface.createFileInterface(_duplojs_lang_common.forwardAsserts(_duplojs_lang_path.normalize(`${parentPath}/${name}`), (result) => _duplojs_lang_common.isType(result, "string") && _duplojs_lang_path.is(result)))), _duplojs_lang_pattern.when((dirent) => dirent.isDirectory(), ({ parentPath, name }) => require_folderInterface.createFolderInterface(_duplojs_lang_common.forwardAsserts(_duplojs_lang_path.normalize(`${parentPath}/${name}`), (result) => _duplojs_lang_common.isType(result, "string") && _duplojs_lang_path.is(result)))), _duplojs_lang_pattern.otherwise(({ parentPath, name }) => require_unknownEntryInterface.createUnknownEntryInterface(_duplojs_lang_common.forwardAsserts(_duplojs_lang_path.normalize(`${parentPath}/${name}`), (result) => _duplojs_lang_common.isType(result, "string") && _duplojs_lang_path.is(result)))))), (value) => _duplojs_lang_either.right("file-system-walk-directory", value))).catch(handleNodeWalkDirectoryError);
-} });
+const walkDirectory = require_implementor.implementFunction("walkDirectory", { NODE: async (path, params) => require_implementor.nodeFileSystem.value.readdir(path, {
+	recursive: params?.recursive ?? false,
+	withFileTypes: true
+}).then((result) => {
+	const currentWorkDirectory = require_getCurrentWorkDirectoryOrThrow.getCurrentWorkDirectoryOrThrow();
+	return _duplojs_lang_common.pipe(result, _duplojs_lang_generator.map((dirent) => ({
+		dirent,
+		path: _duplojs_lang_path.resolveFrom(currentWorkDirectory, [_duplojs_lang_path.normalize(`${dirent.parentPath}/${dirent.name}`)])
+	})), _duplojs_lang_generator.filter((value) => params?.matcher ? params?.matcher(value.path) : true), _duplojs_lang_generator.map(_duplojs_lang_common.innerPipe(_duplojs_lang_pattern.when(({ dirent }) => dirent.isFile(), ({ path }) => require_fileInterface.createFileInterface(path)), _duplojs_lang_pattern.when(({ dirent }) => dirent.isDirectory(), ({ path }) => require_folderInterface.createFolderInterface(path)), _duplojs_lang_pattern.otherwise(({ path }) => require_unknownEntryInterface.createUnknownEntryInterface(path)))), (value) => _duplojs_lang_either.right("file-system-walk-directory", value));
+}).catch(handleNodeWalkDirectoryError) });
 //#endregion
 exports.walkDirectory = walkDirectory;