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

package/dist/command/options/base.mjs

@@ -5,24 +5,30 @@ import * as DArray from "@duplojs/lang/array";
 import * as DString from "@duplojs/lang/string";
 //#region scripts/command/options/base.ts
 const optionKind = createKind("command-option");
-const regexOption = /^(?<dashes>-{1,2})(?<key>[A-Za-z0-9][A-Za-z0-9_-]*)(?:=(?<value>.*))?$/;
+const regexOption = /^(?<dashes>-{1,2})(?<key>(?![0-9]+(?:=|$))[A-Za-z0-9][A-Za-z0-9_-]*)(?:=(?<value>.*))?$/;
+function isOptionToken(input) {
+	return DString.test(input, regexOption);
+}
+function findOptionToken(args, option) {
+	return DArray.reduce(args, DArray.reduceFrom(null), ({ element, next, exit, index }) => {
+		const extractResult = DString.extract(element, regexOption);
+		if (!extractResult) return next(null);
+		const key = extractResult.namedGroups.key;
+		if (option.name !== key && (!DArray.includes(option.aliases, key) || extractResult.namedGroups?.dashes !== "-")) return next(null);
+		return exit({
+			key,
+			value: extractResult.namedGroups?.value,
+			index
+		});
+	});
+}
 function constructOption(kindHandler, createConstructor) {
 	return createConstructor({ init: (name, execute, params, ...rest) => {
 		const self = {
 			...Object.fromEntries(Object.entries(rest[0] ?? {}).map(([key, prop]) => typeof prop === "function" ? [key, (...args) => prop(self, ...args)] : [key, prop])),
 			name,
 			execute: async (args, error) => {
-				const result = DArray.reduce(args, DArray.reduceFrom(null), ({ element, next, exit, index }) => {
-					const extractResult = DString.extract(element, regexOption);
-					if (!extractResult) return next(null);
-					const result = {
-						key: extractResult.namedGroups.key,
-						value: extractResult.namedGroups?.value,
-						index
-					};
-					if (self.name !== result.key && (!DArray.includes(self.aliases, result.key) || extractResult.namedGroups?.dashes !== "-")) return next(null);
-					return exit(result);
-				});
+				const result = findOptionToken(args, self);
 				const { value, argumentRest } = DCommon.justExec(() => {
 					if (!result) return {
 						value: null,
@@ -30,7 +36,7 @@ function constructOption(kindHandler, createConstructor) {
 					};
 					if (result.value === void 0) {
 						const nextArg = args[result.index + 1];
-						if (nextArg === void 0 || DString.test(nextArg, regexOption)) return {
+						if (nextArg === void 0 || isOptionToken(nextArg)) return {
 							value: void 0,
 							argumentRest: DArray.spliceDelete(args, result.index, 1)
 						};
@@ -60,4 +66,4 @@ function constructOption(kindHandler, createConstructor) {
 	} });
 }
 //#endregion
-export { constructOption, optionKind };
+export { constructOption, findOptionToken, isOptionToken, optionKind };

package/dist/command/options/defaults/array.d.ts

@@ -1,5 +1,5 @@
 import { Option } from '../base';
-import { EligibleType } from '../../types';
+import { EligibleType, ForbiddenInvalidIdentifier } from '../../types';
 import * as DCommon from "@duplojs/lang/common";
 import type * as DKind from "@duplojs/lang/kind";
 import * as DDataStructure from "@duplojs/lang/dataStructure";
@@ -13,12 +13,14 @@ export interface ArrayOption<GenericName extends string = string, GenericValue e
     readonly min?: number;
     readonly max?: number;
 }
-export interface CreateArrayOptionParams {
+export interface CreateArrayOptionParams<GenericAliases extends readonly string[] = readonly string[]> {
     description?: string;
-    aliases?: readonly string[];
+    aliases?: (GenericAliases & {
+        readonly [Index in keyof GenericAliases]: ForbiddenInvalidIdentifier<GenericAliases[Index]>;
+    });
     min?: number;
     max?: number;
     required?: boolean;
     separator?: string;
 }
-export declare const createArrayOption: <GenericName extends string, GenericStructure extends DDataStructure.Structure<EligibleType>, GenericValue extends DDataStructure.StructureValue<GenericStructure>, const GenericParams extends CreateArrayOptionParams = {}>(name: GenericName, dataStructure: GenericStructure, params?: GenericParams & CreateArrayOptionParams) => ArrayOption<GenericName, ((readonly GenericValue[] & (DNumber.IsLiteral<Extract<GenericParams["min"], number>> extends true ? DArray.MinElements<Extract<GenericParams["min"], number>> : unknown) & (DNumber.IsLiteral<Extract<GenericParams["max"], number>> extends true ? DArray.MaxElements<Extract<GenericParams["max"], number>> : unknown)) | (DCommon.IsEqual<GenericParams["required"], true> extends true ? never : undefined))>;
+export declare const createArrayOption: <GenericName extends string, GenericStructure extends DDataStructure.Structure<EligibleType>, GenericValue extends DDataStructure.StructureValue<GenericStructure>, const GenericAliases extends readonly string[] = readonly string[], const GenericParams extends CreateArrayOptionParams<GenericAliases> = {}>(name: GenericName & ForbiddenInvalidIdentifier<GenericName>, dataStructure: GenericStructure, params?: GenericParams & CreateArrayOptionParams<GenericAliases>) => ArrayOption<GenericName, ((readonly GenericValue[] & (DNumber.IsLiteral<Extract<GenericParams["min"], number>> extends true ? DArray.MinElements<Extract<GenericParams["min"], number>> : unknown) & (DNumber.IsLiteral<Extract<GenericParams["max"], number>> extends true ? DArray.MaxElements<Extract<GenericParams["max"], number>> : unknown)) | (DCommon.IsEqual<GenericParams["required"], true> extends true ? never : undefined))>;

package/dist/command/options/defaults/boolean.cjs

@@ -1,14 +1,28 @@
+const require_runtime = require("../../../_virtual/_rolldown/runtime.cjs");
 const require_kind = require("../../kind.cjs");
 const require_base = require("../base.cjs");
+let _duplojs_lang_array = require("@duplojs/lang/array");
+_duplojs_lang_array = require_runtime.__toESM(_duplojs_lang_array, 1);
 //#region scripts/command/options/defaults/boolean.ts
 const booleanOptionKind = require_kind.createKind("command-boolean-option");
-const createBooleanOption = require_base.constructOption(booleanOptionKind, ({ init }) => (name, params) => init(name, (self, value, error) => {
-	if (typeof value === "string") return error.addUnexpectedOptionValueIssue(self.name, value);
-	return value !== null;
-}, {
-	description: params?.description ?? null,
-	aliases: params?.aliases ?? []
-}));
+function createBooleanOption(name, params) {
+	const self = {
+		name,
+		description: params?.description ?? null,
+		aliases: params?.aliases ?? [],
+		execute: (args, error) => {
+			const token = require_base.findOptionToken(args, self);
+			if (token?.value !== void 0) return Promise.resolve(error.addUnexpectedOptionValueIssue(self.name, token.value));
+			return Promise.resolve({
+				result: token !== null,
+				argumentRest: token ? _duplojs_lang_array.spliceDelete(args, token.index, 1) : args
+			});
+		},
+		[require_base.optionKind.runTimeKey]: null,
+		[booleanOptionKind.runTimeKey]: null
+	};
+	return self;
+}
 //#endregion
 exports.booleanOptionKind = booleanOptionKind;
 exports.createBooleanOption = createBooleanOption;

package/dist/command/options/defaults/boolean.d.ts

@@ -1,11 +1,14 @@
 import { Option } from '../base';
+import { ForbiddenInvalidIdentifier } from '../../types';
 import type * as DCommon from "@duplojs/lang/common";
 import type * as DKind from "@duplojs/lang/kind";
 export declare const booleanOptionKind: DKind.Handler<DKind.Definition<"@DuplojsServerCommand/command-boolean-option", unknown>>;
 export interface BooleanOption<GenericName extends string = string> extends DCommon.Forward<Option<GenericName, boolean> & DKind.Kind<typeof booleanOptionKind>> {
 }
-export interface CreateBooleanOptionParams {
+export interface CreateBooleanOptionParams<GenericAliases extends readonly string[] = readonly string[]> {
     description?: string;
-    aliases?: readonly string[];
+    aliases?: (GenericAliases & {
+        readonly [Index in keyof GenericAliases]: ForbiddenInvalidIdentifier<GenericAliases[Index]>;
+    });
 }
-export declare const createBooleanOption: <GenericName extends string>(name: GenericName, params?: CreateBooleanOptionParams) => NoInfer<BooleanOption<GenericName>>;
+export declare function createBooleanOption<GenericName extends string, const GenericAliases extends readonly string[] = readonly string[]>(name: GenericName & ForbiddenInvalidIdentifier<GenericName>, params?: CreateBooleanOptionParams<GenericAliases>): BooleanOption<GenericName>;

package/dist/command/options/defaults/boolean.mjs

@@ -1,13 +1,25 @@
 import { createKind } from "../../kind.mjs";
-import { constructOption } from "../base.mjs";
+import { findOptionToken, optionKind } from "../base.mjs";
+import * as DArray from "@duplojs/lang/array";
 //#region scripts/command/options/defaults/boolean.ts
 const booleanOptionKind = createKind("command-boolean-option");
-const createBooleanOption = constructOption(booleanOptionKind, ({ init }) => (name, params) => init(name, (self, value, error) => {
-	if (typeof value === "string") return error.addUnexpectedOptionValueIssue(self.name, value);
-	return value !== null;
-}, {
-	description: params?.description ?? null,
-	aliases: params?.aliases ?? []
-}));
+function createBooleanOption(name, params) {
+	const self = {
+		name,
+		description: params?.description ?? null,
+		aliases: params?.aliases ?? [],
+		execute: (args, error) => {
+			const token = findOptionToken(args, self);
+			if (token?.value !== void 0) return Promise.resolve(error.addUnexpectedOptionValueIssue(self.name, token.value));
+			return Promise.resolve({
+				result: token !== null,
+				argumentRest: token ? DArray.spliceDelete(args, token.index, 1) : args
+			});
+		},
+		[optionKind.runTimeKey]: null,
+		[booleanOptionKind.runTimeKey]: null
+	};
+	return self;
+}
 //#endregion
 export { booleanOptionKind, createBooleanOption };

package/dist/command/options/defaults/simple.d.ts

@@ -1,5 +1,5 @@
 import { Option } from '../base';
-import { EligibleType } from '../../types';
+import { EligibleType, ForbiddenInvalidIdentifier } from '../../types';
 import type * as DCommon from "@duplojs/lang/common";
 import type * as DKind from "@duplojs/lang/kind";
 import type * as DDataStructure from "@duplojs/lang/dataStructure";
@@ -8,9 +8,11 @@ export interface SimpleOption<GenericName extends string = string, GenericValue
     readonly dataStructure: DDataStructure.Structure<GenericValue>;
     readonly required: boolean;
 }
-export interface CreateSimpleOptionParams {
+export interface CreateSimpleOptionParams<GenericAliases extends readonly string[] = readonly string[]> {
     description?: string;
-    aliases?: readonly string[];
+    aliases?: (GenericAliases & {
+        readonly [Index in keyof GenericAliases]: ForbiddenInvalidIdentifier<GenericAliases[Index]>;
+    });
     required?: boolean;
 }
-export declare const createOption: <GenericName extends string, GenericStructure extends DDataStructure.Structure<EligibleType>, GenericValue extends DDataStructure.StructureValue<GenericStructure>, const GenericParams extends CreateSimpleOptionParams = {}>(name: GenericName, dataStructure: GenericStructure, params?: GenericParams & CreateSimpleOptionParams) => SimpleOption<GenericName, (GenericValue | (DCommon.IsEqual<GenericParams["required"], true> extends true ? never : undefined))>;
+export declare const createOption: <GenericName extends string, GenericStructure extends DDataStructure.Structure<EligibleType>, GenericValue extends DDataStructure.StructureValue<GenericStructure>, const GenericAliases extends readonly string[] = readonly string[], const GenericParams extends CreateSimpleOptionParams<GenericAliases> = {}>(name: GenericName & ForbiddenInvalidIdentifier<GenericName>, dataStructure: GenericStructure, params?: GenericParams & CreateSimpleOptionParams<GenericAliases>) => SimpleOption<GenericName, (GenericValue | (DCommon.IsEqual<GenericParams["required"], true> extends true ? never : undefined))>;

package/dist/command/types/forbiddenInvalidIdentifier.d.ts

@@ -0,0 +1,6 @@
+import type * as DCommon from "@duplojs/lang/common";
+import type * as DString from "@duplojs/lang/string";
+type AlphanumericCharacter = (DString.CharactersRangeStore["a-z" | "A-Z"] | DString.Digit);
+type AllowedIdentifierCharacter = (AlphanumericCharacter | "_" | "-");
+export type ForbiddenInvalidIdentifier<GenericName extends string> = DCommon.ContainExtends<GenericName, DCommon.BaseConstraint> extends true ? DCommon.ComputedTypeError<"Identifier cannot be a constrained string."> : DString.IsLiteral<GenericName> extends true ? DCommon.IsUnion<GenericName> extends true ? DCommon.ComputedTypeError<"Identifier must be a single string literal."> : DCommon.IsEqual<GenericName, ""> extends true ? DCommon.ComputedTypeError<"Identifier cannot be empty."> : DString.StartsWith<GenericName, AlphanumericCharacter> extends true ? DString.IsAllowedString<GenericName, AllowedIdentifierCharacter> extends true ? DString.IsAllowedString<GenericName, DString.Digit> extends false ? unknown : DCommon.ComputedTypeError<`Identifier "${GenericName}" cannot contain only digits.`> : DCommon.ComputedTypeError<`Identifier "${GenericName}" contains invalid characters (allowed: A-Z, a-z, 0-9, "_" and "-").`> : DCommon.ComputedTypeError<`Identifier "${GenericName}" must start with a letter or digit.`> : DCommon.ComputedTypeError<"Identifier must be a known string literal.">;
+export {};

package/dist/command/types/index.d.ts

@@ -1,2 +1,3 @@
 export type * from './eligibleType';
 export type * from './forbiddenDuplicateName';
+export type * from './forbiddenInvalidIdentifier';

package/dist/common/environmentVariable/index.d.ts

@@ -3,7 +3,7 @@ import * as DEither from "@duplojs/lang/either";
 import type * as DPath from "@duplojs/lang/path";
 import type * as DSFile from '../../file';
 export interface EnvironmentVariableFileParams {
-    includedEnvironmentFiles?: (string & DPath.Path)[];
+    includedEnvironmentFiles?: DPath.AnyPath[];
     override?: boolean;
     justRead?: boolean;
     codecs?: DDataStructure.Codecs;

package/dist/common/environmentVariable/overrideEnvironmentVariables.d.ts

@@ -1,3 +1,3 @@
-export declare function overrideEnvironmentVariables(arrayEnv: Record<string, string>[], override: boolean): {
+export declare function overrideEnvironmentVariables(arrayEnv: readonly Record<string, string>[], override: boolean): {
     [x: string]: string;
 };

package/dist/common/environmentVariable/parseEnvironmentFiles.d.ts

@@ -1,4 +1,5 @@
 import type * as DPath from "@duplojs/lang/path";
 import * as DEither from "@duplojs/lang/either";
+import * as DSFile from '../../file';
 export declare function parseEnvironmentLine(line: string): Record<string, string>;
-export declare function parseEnvironmentFiles(baseEnv: Record<string, string>, paths: (string & DPath.Path)[]): Promise<DEither.Left<"file-system-read-text-file-not-found", unknown> | DEither.Left<"file-system-read-text-file-permission-denied", unknown> | DEither.Left<"file-system-read-text-file-is-directory", unknown> | DEither.Left<"file-system-read-text-file-not-directory", unknown> | DEither.Left<"file-system-read-text-file-too-many-open-files", unknown> | DEither.Left<"file-system-read-text-file-busy", unknown> | DEither.Left<"file-system-read-text-file-error", unknown> | Record<string, string>[]>;
+export declare function parseEnvironmentFiles(baseEnv: Record<string, string>, paths: DPath.AnyPath[]): Promise<DEither.Left<"file-system-read-text-file-error", DSFile.ReadTextFileErrors> | readonly Record<string, string>[]>;

package/dist/common/index.cjs

@@ -7,6 +7,7 @@ const require_index = require("./environmentVariable/index.cjs");
 const require_environmentVariableOrThrow = require("./environmentVariableOrThrow.cjs");
 const require_exitProcess = require("./exitProcess.cjs");
 const require_getProcessArguments = require("./getProcessArguments.cjs");
+const require_getCurrentDirectoryName = require("./meta/getCurrentDirectoryName.cjs");
 //#region scripts/common/index.ts
 var common_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	EnvironmentVariableError: () => require_environmentVariableOrThrow.EnvironmentVariableError,
@@ -15,6 +16,7 @@ var common_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	environmentVariable: () => require_index.environmentVariable,
 	environmentVariableOrThrow: () => require_environmentVariableOrThrow.environmentVariableOrThrow,
 	exitProcess: () => require_exitProcess.exitProcess,
+	getCurrentDirectoryName: () => require_getCurrentDirectoryName.getCurrentDirectoryName,
 	getCurrentWorkDirectory: () => require_getCurrentWorkDirectory.getCurrentWorkDirectory,
 	getCurrentWorkDirectoryOrThrow: () => require_getCurrentWorkDirectoryOrThrow.getCurrentWorkDirectoryOrThrow,
 	getProcessArguments: () => require_getProcessArguments.getProcessArguments,
@@ -34,6 +36,7 @@ Object.defineProperty(exports, "common_exports", {
 exports.environmentVariable = require_index.environmentVariable;
 exports.environmentVariableOrThrow = require_environmentVariableOrThrow.environmentVariableOrThrow;
 exports.exitProcess = require_exitProcess.exitProcess;
+exports.getCurrentDirectoryName = require_getCurrentDirectoryName.getCurrentDirectoryName;
 exports.getCurrentWorkDirectory = require_getCurrentWorkDirectory.getCurrentWorkDirectory;
 exports.getCurrentWorkDirectoryOrThrow = require_getCurrentWorkDirectoryOrThrow.getCurrentWorkDirectoryOrThrow;
 exports.getProcessArguments = require_getProcessArguments.getProcessArguments;

package/dist/common/index.d.ts

@@ -6,3 +6,4 @@ export * from './environmentVariable';
 export * from './environmentVariableOrThrow';
 export * from './exitProcess';
 export * from './getProcessArguments';
+export * from './meta';

package/dist/common/index.mjs

@@ -7,6 +7,7 @@ import { environmentVariable } from "./environmentVariable/index.mjs";
 import { EnvironmentVariableError, environmentVariableOrThrow } from "./environmentVariableOrThrow.mjs";
 import { exitProcess } from "./exitProcess.mjs";
 import { getProcessArguments } from "./getProcessArguments.mjs";
+import { getCurrentDirectoryName } from "./meta/getCurrentDirectoryName.mjs";
 //#region scripts/common/index.ts
 var common_exports = /* @__PURE__ */ __exportAll({
 	EnvironmentVariableError: () => EnvironmentVariableError,
@@ -15,6 +16,7 @@ var common_exports = /* @__PURE__ */ __exportAll({
 	environmentVariable: () => environmentVariable,
 	environmentVariableOrThrow: () => environmentVariableOrThrow,
 	exitProcess: () => exitProcess,
+	getCurrentDirectoryName: () => getCurrentDirectoryName,
 	getCurrentWorkDirectory: () => getCurrentWorkDirectory,
 	getCurrentWorkDirectoryOrThrow: () => getCurrentWorkDirectoryOrThrow,
 	getProcessArguments: () => getProcessArguments,
@@ -22,4 +24,4 @@ var common_exports = /* @__PURE__ */ __exportAll({
 	setCurrentWorkingDirectoryOrThrow: () => setCurrentWorkingDirectoryOrThrow
 });
 //#endregion
-export { EnvironmentVariableError, GetCurrentWorkDirectoryError, SetCurrentWorkingDirectoryError, common_exports, environmentVariable, environmentVariableOrThrow, exitProcess, getCurrentWorkDirectory, getCurrentWorkDirectoryOrThrow, getProcessArguments, setCurrentWorkingDirectory, setCurrentWorkingDirectoryOrThrow };
+export { EnvironmentVariableError, GetCurrentWorkDirectoryError, SetCurrentWorkingDirectoryError, common_exports, environmentVariable, environmentVariableOrThrow, exitProcess, getCurrentDirectoryName, getCurrentWorkDirectory, getCurrentWorkDirectoryOrThrow, getProcessArguments, setCurrentWorkingDirectory, setCurrentWorkingDirectoryOrThrow };

package/dist/common/meta/getCurrentDirectoryName.cjs

@@ -0,0 +1,10 @@
+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_path = require("@duplojs/lang/path");
+_duplojs_lang_path = require_runtime.__toESM(_duplojs_lang_path, 1);
+//#region scripts/common/meta/getCurrentDirectoryName.ts
+const getCurrentDirectoryName = require_implementor.implementFunction("getCurrentDirectoryName", { NODE: (importMeta) => _duplojs_lang_common.pipe(importMeta.dirname, _duplojs_lang_path.createAbsoluteOrThrow) });
+//#endregion
+exports.getCurrentDirectoryName = getCurrentDirectoryName;

package/dist/common/meta/getCurrentDirectoryName.d.ts

@@ -0,0 +1,7 @@
+import * as DPath from "@duplojs/lang/path";
+declare module '../../implementor' {
+    interface ServerFunction {
+        getCurrentDirectoryName(importMeta: ImportMeta): string & DPath.Absolute;
+    }
+}
+export declare const getCurrentDirectoryName: (importMeta: ImportMeta) => string & DPath.Absolute;

package/dist/common/meta/getCurrentDirectoryName.mjs

@@ -0,0 +1,7 @@
+import { implementFunction } from "../../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DPath from "@duplojs/lang/path";
+//#region scripts/common/meta/getCurrentDirectoryName.ts
+const getCurrentDirectoryName = implementFunction("getCurrentDirectoryName", { NODE: (importMeta) => DCommon.pipe(importMeta.dirname, DPath.createAbsoluteOrThrow) });
+//#endregion
+export { getCurrentDirectoryName };

package/dist/common/meta/index.d.ts

@@ -0,0 +1,7 @@
+import type * as DKind from "@duplojs/lang/kind";
+declare const importMetaKind: DKind.Handler<DKind.Definition<"@DuplojsServer/import-meta", unknown>>;
+declare global {
+    interface ImportMeta extends DKind.Kind<typeof importMetaKind> {
+    }
+}
+export * from './getCurrentDirectoryName';

package/dist/dataStructure/common/codec/defaults/json.cjs

@@ -1,6 +1,8 @@
 const require_runtime = require("../../../../_virtual/_rolldown/runtime.cjs");
 const require_fileInterface = require("../../../../file/fileInterface.cjs");
+const require_folderInterface = require("../../../../file/folderInterface.cjs");
 const require_file = require("../../../fundamentalType/file.cjs");
+const require_folder = require("../../../fundamentalType/folder.cjs");
 let _duplojs_lang_path = require("@duplojs/lang/path");
 _duplojs_lang_path = require_runtime.__toESM(_duplojs_lang_path, 1);
 let _duplojs_lang_dataStructure = require("@duplojs/lang/dataStructure");
@@ -8,7 +10,16 @@ _duplojs_lang_dataStructure = require_runtime.__toESM(_duplojs_lang_dataStructur
 //#region scripts/dataStructure/common/codec/defaults/json.ts
 const codecsJson = _duplojs_lang_dataStructure.createCodecs({
 	..._duplojs_lang_dataStructure.codecsJson.definition,
-	file: _duplojs_lang_dataStructure.createCodec(require_file.TheFile, (data) => typeof data === "string" && _duplojs_lang_path.is(data), (data) => data.path, (data) => require_fileInterface.createFileInterface(data))
+	file: _duplojs_lang_dataStructure.createCodec(require_file.TheFile, (data) => typeof data === "string", (data) => data.path, (data) => {
+		const result = _duplojs_lang_path.normalize(data);
+		if (!result) return _duplojs_lang_dataStructure.ErrorSymbol;
+		return require_fileInterface.createFileInterface(result);
+	}),
+	folder: _duplojs_lang_dataStructure.createCodec(require_folder.TheFolder, (data) => typeof data === "string", (data) => data.path, (data) => {
+		const result = _duplojs_lang_path.normalize(data);
+		if (!result) return _duplojs_lang_dataStructure.ErrorSymbol;
+		return require_folderInterface.createFolderInterface(result);
+	})
 });
 //#endregion
 exports.codecsJson = codecsJson;

package/dist/dataStructure/common/codec/defaults/json.d.ts

@@ -1,8 +1,8 @@
-import * as DPath from "@duplojs/lang/path";
 import * as DDataStructure from "@duplojs/lang/dataStructure";
 import * as FundamentalType from "../../../fundamentalType";
 export declare const codecsJson: DDataStructure.Codecs<{
-    file: DDataStructure.Codec<FundamentalType.TheFile, string & DPath.Path>;
+    file: DDataStructure.Codec<FundamentalType.TheFile, string>;
+    folder: DDataStructure.Codec<FundamentalType.TheFolder, string>;
     bigint: import('@duplojs/lang/dataStructure').Codec<DDataStructure.TheBigint, string>;
     date: import('@duplojs/lang/dataStructure').Codec<DDataStructure.TheDate, string>;
     time: import('@duplojs/lang/dataStructure').Codec<DDataStructure.TheTime, string>;

package/dist/dataStructure/common/codec/defaults/json.mjs

@@ -1,11 +1,22 @@
 import { createFileInterface } from "../../../../file/fileInterface.mjs";
+import { createFolderInterface } from "../../../../file/folderInterface.mjs";
 import { TheFile } from "../../../fundamentalType/file.mjs";
+import { TheFolder } from "../../../fundamentalType/folder.mjs";
 import * as DPath from "@duplojs/lang/path";
 import * as DDataStructure from "@duplojs/lang/dataStructure";
 //#region scripts/dataStructure/common/codec/defaults/json.ts
 const codecsJson = DDataStructure.createCodecs({
 	...DDataStructure.codecsJson.definition,
-	file: DDataStructure.createCodec(TheFile, (data) => typeof data === "string" && DPath.is(data), (data) => data.path, (data) => createFileInterface(data))
+	file: DDataStructure.createCodec(TheFile, (data) => typeof data === "string", (data) => data.path, (data) => {
+		const result = DPath.normalize(data);
+		if (!result) return DDataStructure.ErrorSymbol;
+		return createFileInterface(result);
+	}),
+	folder: DDataStructure.createCodec(TheFolder, (data) => typeof data === "string", (data) => data.path, (data) => {
+		const result = DPath.normalize(data);
+		if (!result) return DDataStructure.ErrorSymbol;
+		return createFolderInterface(result);
+	})
 });
 //#endregion
 export { codecsJson };

package/dist/dataStructure/common/codec/defaults/string.cjs

@@ -1,6 +1,8 @@
 const require_runtime = require("../../../../_virtual/_rolldown/runtime.cjs");
 const require_fileInterface = require("../../../../file/fileInterface.cjs");
+const require_folderInterface = require("../../../../file/folderInterface.cjs");
 const require_file = require("../../../fundamentalType/file.cjs");
+const require_folder = require("../../../fundamentalType/folder.cjs");
 let _duplojs_lang_path = require("@duplojs/lang/path");
 _duplojs_lang_path = require_runtime.__toESM(_duplojs_lang_path, 1);
 let _duplojs_lang_dataStructure = require("@duplojs/lang/dataStructure");
@@ -8,7 +10,16 @@ _duplojs_lang_dataStructure = require_runtime.__toESM(_duplojs_lang_dataStructur
 //#region scripts/dataStructure/common/codec/defaults/string.ts
 const codecsString = _duplojs_lang_dataStructure.createCodecs({
 	..._duplojs_lang_dataStructure.codecsString.definition,
-	file: _duplojs_lang_dataStructure.createCodec(require_file.TheFile, (data) => typeof data === "string" && _duplojs_lang_path.is(data), (data) => data.path, (data) => require_fileInterface.createFileInterface(data))
+	file: _duplojs_lang_dataStructure.createCodec(require_file.TheFile, (data) => typeof data === "string", (data) => data.path, (data) => {
+		const result = _duplojs_lang_path.normalize(data);
+		if (!result) return _duplojs_lang_dataStructure.ErrorSymbol;
+		return require_fileInterface.createFileInterface(result);
+	}),
+	folder: _duplojs_lang_dataStructure.createCodec(require_folder.TheFolder, (data) => typeof data === "string", (data) => data.path, (data) => {
+		const result = _duplojs_lang_path.normalize(data);
+		if (!result) return _duplojs_lang_dataStructure.ErrorSymbol;
+		return require_folderInterface.createFolderInterface(result);
+	})
 });
 //#endregion
 exports.codecsString = codecsString;

package/dist/dataStructure/common/codec/defaults/string.d.ts

@@ -1,8 +1,8 @@
-import * as DPath from "@duplojs/lang/path";
 import * as DDataStructure from "@duplojs/lang/dataStructure";
 import * as FundamentalType from "../../../fundamentalType";
 export declare const codecsString: DDataStructure.Codecs<{
-    file: DDataStructure.Codec<FundamentalType.TheFile, string & DPath.Path>;
+    file: DDataStructure.Codec<FundamentalType.TheFile, string>;
+    folder: DDataStructure.Codec<FundamentalType.TheFolder, string>;
     bigint: import('@duplojs/lang/dataStructure').Codec<DDataStructure.TheBigint, string>;
     boolean: import('@duplojs/lang/dataStructure').Codec<DDataStructure.TheBoolean, "true" | "false">;
     date: import('@duplojs/lang/dataStructure').Codec<DDataStructure.TheDate, string>;

package/dist/dataStructure/common/codec/defaults/string.mjs

@@ -1,11 +1,22 @@
 import { createFileInterface } from "../../../../file/fileInterface.mjs";
+import { createFolderInterface } from "../../../../file/folderInterface.mjs";
 import { TheFile } from "../../../fundamentalType/file.mjs";
+import { TheFolder } from "../../../fundamentalType/folder.mjs";
 import * as DPath from "@duplojs/lang/path";
 import * as DDataStructure from "@duplojs/lang/dataStructure";
 //#region scripts/dataStructure/common/codec/defaults/string.ts
 const codecsString = DDataStructure.createCodecs({
 	...DDataStructure.codecsString.definition,
-	file: DDataStructure.createCodec(TheFile, (data) => typeof data === "string" && DPath.is(data), (data) => data.path, (data) => createFileInterface(data))
+	file: DDataStructure.createCodec(TheFile, (data) => typeof data === "string", (data) => data.path, (data) => {
+		const result = DPath.normalize(data);
+		if (!result) return DDataStructure.ErrorSymbol;
+		return createFileInterface(result);
+	}),
+	folder: DDataStructure.createCodec(TheFolder, (data) => typeof data === "string", (data) => data.path, (data) => {
+		const result = DPath.normalize(data);
+		if (!result) return DDataStructure.ErrorSymbol;
+		return createFolderInterface(result);
+	})
 });
 //#endregion
 export { codecsString };

package/dist/dataStructure/common/error/defaultInterpreter.cjs

@@ -6,6 +6,7 @@ _duplojs_lang_dataStructure = require_runtime.__toESM(_duplojs_lang_dataStructur
 const defaultErrorInterpreterDataStructureDictionary = {
 	..._duplojs_lang_dataStructure.defaultErrorInterpreterDataStructureDictionary,
 	"@DuplojsServerDataStructure/file-type": () => "Expected a valid file.",
+	"@DuplojsServerDataStructure/folder-type": () => "Expected a valid folder.",
 	"@DuplojsServerDataStructure/size-constraint": (source) => {
 		const { min, max } = source.definition;
 		if (min !== void 0 && max !== void 0) return `Expected a file size between ${min} and ${max} bytes.`;
@@ -14,7 +15,8 @@ const defaultErrorInterpreterDataStructureDictionary = {
 		return "Expected a valid file size.";
 	},
 	"@DuplojsServerDataStructure/mime-type-constraint": (source) => `Expected a file with a MIME type matching ${source.definition.regex.toString()}.`,
-	"@DuplojsServerDataStructure/exist-constraint": () => "Expected the file to exist."
+	"@DuplojsServerDataStructure/file-exist-constraint": () => "Expected the file to exist.",
+	"@DuplojsServerDataStructure/folder-exist-constraint": () => "Expected the folder to exist."
 };
 const defaultErrorInterpreterCodecDictionary = [..._duplojs_lang_dataStructure.defaultErrorInterpreterCodecDictionary, [require_json.codecsJson.definition.file, (_codec, issue) => {
 	if (issue.from === "predicate") return _duplojs_lang_dataStructure.encodeIssueKind.has(issue) ? "The JSON file codec must produce a valid file path string." : "Expected a valid file path string for the JSON file codec.";

package/dist/dataStructure/common/error/defaultInterpreter.d.ts

@@ -1,9 +1,11 @@
 import * as DDataStructure from "@duplojs/lang/dataStructure";
 export declare const defaultErrorInterpreterDataStructureDictionary: {
     readonly "@DuplojsServerDataStructure/file-type": () => string;
+    readonly "@DuplojsServerDataStructure/folder-type": () => string;
     readonly "@DuplojsServerDataStructure/size-constraint": (source: import('../..').SizeConstraint) => string;
     readonly "@DuplojsServerDataStructure/mime-type-constraint": (source: import('../..').MimeTypeConstraint) => string;
-    readonly "@DuplojsServerDataStructure/exist-constraint": () => string;
+    readonly "@DuplojsServerDataStructure/file-exist-constraint": () => string;
+    readonly "@DuplojsServerDataStructure/folder-exist-constraint": () => string;
     readonly "@DuplojsLangDataStructure/array-structure": () => string;
     readonly "@DuplojsLangDataStructure/lazy-structure": () => string;
     readonly "@DuplojsLangDataStructure/non-encodable-string-structure": (source: import('@duplojs/lang/dataStructure').NonEncodableStringStructure) => string;
@@ -29,9 +31,11 @@ export declare const defaultErrorInterpreterDataStructureDictionary: {
     readonly "@DuplojsLangDataStructure/between-than-constraint": (source: import('@duplojs/lang/dataStructure').BetweenThanConstraint<number, number>) => string;
     readonly "@DuplojsLangDataStructure/between-than-or-equal-constraint": (source: import('@duplojs/lang/dataStructure').BetweenThanOrEqualConstraint<number, number>) => string;
     readonly "@DuplojsLangDataStructure/email-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/ends-with-constraint": (source: import('@duplojs/lang/dataStructure').EndsWithConstraint<string>) => string;
     readonly "@DuplojsLangDataStructure/even-constraint": () => string;
     readonly "@DuplojsLangDataStructure/greater-than-constraint": (source: import('@duplojs/lang/dataStructure').GreaterThanConstraint<number>) => string;
     readonly "@DuplojsLangDataStructure/greater-than-or-equal-constraint": (source: import('@duplojs/lang/dataStructure').GreaterThanOrEqualConstraint<number>) => string;
+    readonly "@DuplojsLangDataStructure/include-constraint": (source: import('@duplojs/lang/dataStructure').IncludeConstraint<string>) => string;
     readonly "@DuplojsLangDataStructure/integer-constraint": () => string;
     readonly "@DuplojsLangDataStructure/less-than-constraint": (source: import('@duplojs/lang/dataStructure').LessThanConstraint<number>) => string;
     readonly "@DuplojsLangDataStructure/less-than-or-equal-constraint": (source: import('@duplojs/lang/dataStructure').LessThanOrEqualConstraint<number>) => string;
@@ -51,6 +55,7 @@ export declare const defaultErrorInterpreterDataStructureDictionary: {
     readonly "@DuplojsLangDataStructure/regex-constraint": (source: import('@duplojs/lang/dataStructure').RegexConstraint) => string;
     readonly "@DuplojsLangDataStructure/safe-constraint": () => string;
     readonly "@DuplojsLangDataStructure/segment-path-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/starts-with-constraint": (source: import('@duplojs/lang/dataStructure').StartsWithConstraint<string>) => string;
     readonly "@DuplojsLangDataStructure/strict-negative-constraint": () => string;
     readonly "@DuplojsLangDataStructure/strict-positive-constraint": () => string;
     readonly "@DuplojsLangDataStructure/string-length-equal-constraint": (source: import('@duplojs/lang/dataStructure').StringLengthEqualConstraint<number>) => string;
@@ -61,4 +66,4 @@ export declare const defaultErrorInterpreterDataStructureDictionary: {
     readonly "@DuplojsLangModeling/new-type-structure": () => string;
     readonly "@DuplojsLangModeling/tagged-object-structure": (source: import('@duplojs/lang/modeling').TaggedObjectStructure<import('@duplojs/lang/modeling').ObjectTag<string>>) => string;
 };
-export declare const defaultErrorInterpreterCodecDictionary: [[DDataStructure.Codec<DDataStructure.TheBigint, string>, (codec: import('@duplojs/lang/dataStructure').Codec, issue: import('@duplojs/lang/dataStructure').EncodeIssue | import('@duplojs/lang/dataStructure').DecodeIssue) => string], [DDataStructure.Codec<DDataStructure.TheDate, string>, (codec: import('@duplojs/lang/dataStructure').Codec, issue: import('@duplojs/lang/dataStructure').EncodeIssue | import('@duplojs/lang/dataStructure').DecodeIssue) => string], [DDataStructure.Codec<DDataStructure.TheTime, string>, (codec: import('@duplojs/lang/dataStructure').Codec, issue: import('@duplojs/lang/dataStructure').EncodeIssue | import('@duplojs/lang/dataStructure').DecodeIssue) => string], [DDataStructure.Codec<DDataStructure.TheBigint, string>, (codec: import('@duplojs/lang/dataStructure').Codec, issue: import('@duplojs/lang/dataStructure').EncodeIssue | import('@duplojs/lang/dataStructure').DecodeIssue) => string], [DDataStructure.Codec<DDataStructure.TheBoolean, "true" | "false">, (codec: import('@duplojs/lang/dataStructure').Codec, issue: import('@duplojs/lang/dataStructure').EncodeIssue | import('@duplojs/lang/dataStructure').DecodeIssue) => string], [DDataStructure.Codec<DDataStructure.TheDate, string>, (codec: import('@duplojs/lang/dataStructure').Codec, issue: import('@duplojs/lang/dataStructure').EncodeIssue | import('@duplojs/lang/dataStructure').DecodeIssue) => string], [DDataStructure.Codec<DDataStructure.TheNull, "null">, (codec: import('@duplojs/lang/dataStructure').Codec, issue: import('@duplojs/lang/dataStructure').EncodeIssue | import('@duplojs/lang/dataStructure').DecodeIssue) => string], [DDataStructure.Codec<DDataStructure.TheNumber, string & import('@duplojs/lang/string').Number>, (codec: import('@duplojs/lang/dataStructure').Codec, issue: import('@duplojs/lang/dataStructure').EncodeIssue | import('@duplojs/lang/dataStructure').DecodeIssue) => string], [DDataStructure.Codec<DDataStructure.TheTime, string>, (codec: import('@duplojs/lang/dataStructure').Codec, issue: import('@duplojs/lang/dataStructure').EncodeIssue | import('@duplojs/lang/dataStructure').DecodeIssue) => string], [DDataStructure.Codec<DDataStructure.TheUndefined, "undefined" | undefined>, (codec: import('@duplojs/lang/dataStructure').Codec, issue: import('@duplojs/lang/dataStructure').EncodeIssue | import('@duplojs/lang/dataStructure').DecodeIssue) => string], [DDataStructure.Codec<import('../..').TheFile, string & import('@duplojs/lang/path').Path>, (_codec: DDataStructure.Codec<DDataStructure.FundamentalType<unknown>, unknown>, issue: DDataStructure.EncodeIssue | DDataStructure.DecodeIssue) => string]];
+export declare const defaultErrorInterpreterCodecDictionary: [[DDataStructure.Codec<DDataStructure.TheBigint, string>, (codec: import('@duplojs/lang/dataStructure').Codec, issue: import('@duplojs/lang/dataStructure').EncodeIssue | import('@duplojs/lang/dataStructure').DecodeIssue) => string], [DDataStructure.Codec<DDataStructure.TheDate, string>, (codec: import('@duplojs/lang/dataStructure').Codec, issue: import('@duplojs/lang/dataStructure').EncodeIssue | import('@duplojs/lang/dataStructure').DecodeIssue) => string], [DDataStructure.Codec<DDataStructure.TheTime, string>, (codec: import('@duplojs/lang/dataStructure').Codec, issue: import('@duplojs/lang/dataStructure').EncodeIssue | import('@duplojs/lang/dataStructure').DecodeIssue) => string], [DDataStructure.Codec<DDataStructure.TheBigint, string>, (codec: import('@duplojs/lang/dataStructure').Codec, issue: import('@duplojs/lang/dataStructure').EncodeIssue | import('@duplojs/lang/dataStructure').DecodeIssue) => string], [DDataStructure.Codec<DDataStructure.TheBoolean, "true" | "false">, (codec: import('@duplojs/lang/dataStructure').Codec, issue: import('@duplojs/lang/dataStructure').EncodeIssue | import('@duplojs/lang/dataStructure').DecodeIssue) => string], [DDataStructure.Codec<DDataStructure.TheDate, string>, (codec: import('@duplojs/lang/dataStructure').Codec, issue: import('@duplojs/lang/dataStructure').EncodeIssue | import('@duplojs/lang/dataStructure').DecodeIssue) => string], [DDataStructure.Codec<DDataStructure.TheNull, "null">, (codec: import('@duplojs/lang/dataStructure').Codec, issue: import('@duplojs/lang/dataStructure').EncodeIssue | import('@duplojs/lang/dataStructure').DecodeIssue) => string], [DDataStructure.Codec<DDataStructure.TheNumber, string & import('@duplojs/lang/string').Number>, (codec: import('@duplojs/lang/dataStructure').Codec, issue: import('@duplojs/lang/dataStructure').EncodeIssue | import('@duplojs/lang/dataStructure').DecodeIssue) => string], [DDataStructure.Codec<DDataStructure.TheTime, string>, (codec: import('@duplojs/lang/dataStructure').Codec, issue: import('@duplojs/lang/dataStructure').EncodeIssue | import('@duplojs/lang/dataStructure').DecodeIssue) => string], [DDataStructure.Codec<DDataStructure.TheUndefined, "undefined" | undefined>, (codec: import('@duplojs/lang/dataStructure').Codec, issue: import('@duplojs/lang/dataStructure').EncodeIssue | import('@duplojs/lang/dataStructure').DecodeIssue) => string], [DDataStructure.Codec<import('../..').TheFile, string>, (_codec: DDataStructure.Codec<DDataStructure.FundamentalType<unknown>, unknown>, issue: DDataStructure.EncodeIssue | DDataStructure.DecodeIssue) => string]];

package/dist/dataStructure/common/error/defaultInterpreter.mjs

@@ -4,6 +4,7 @@ import * as DDataStructure from "@duplojs/lang/dataStructure";
 const defaultErrorInterpreterDataStructureDictionary = {
 	...DDataStructure.defaultErrorInterpreterDataStructureDictionary,
 	"@DuplojsServerDataStructure/file-type": () => "Expected a valid file.",
+	"@DuplojsServerDataStructure/folder-type": () => "Expected a valid folder.",
 	"@DuplojsServerDataStructure/size-constraint": (source) => {
 		const { min, max } = source.definition;
 		if (min !== void 0 && max !== void 0) return `Expected a file size between ${min} and ${max} bytes.`;
@@ -12,7 +13,8 @@ const defaultErrorInterpreterDataStructureDictionary = {
 		return "Expected a valid file size.";
 	},
 	"@DuplojsServerDataStructure/mime-type-constraint": (source) => `Expected a file with a MIME type matching ${source.definition.regex.toString()}.`,
-	"@DuplojsServerDataStructure/exist-constraint": () => "Expected the file to exist."
+	"@DuplojsServerDataStructure/file-exist-constraint": () => "Expected the file to exist.",
+	"@DuplojsServerDataStructure/folder-exist-constraint": () => "Expected the folder to exist."
 };
 const defaultErrorInterpreterCodecDictionary = [...DDataStructure.defaultErrorInterpreterCodecDictionary, [codecsJson.definition.file, (_codec, issue) => {
 	if (issue.from === "predicate") return DDataStructure.encodeIssueKind.has(issue) ? "The JSON file codec must produce a valid file path string." : "Expected a valid file path string for the JSON file codec.";

package/dist/dataStructure/constraint/{exist.cjs → fileExist.cjs}

@@ -4,9 +4,9 @@ let _duplojs_lang_either = require("@duplojs/lang/either");
 _duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
 let _duplojs_lang_dataStructure = require("@duplojs/lang/dataStructure");
 _duplojs_lang_dataStructure = require_runtime.__toESM(_duplojs_lang_dataStructure, 1);
-//#region scripts/dataStructure/constraint/exist.ts
-const existConstraintKind = require_kind.createKind("exist-constraint");
-const ExistConstraint = _duplojs_lang_dataStructure.createConstraint(existConstraintKind, ({ init }) => () => init({}, {
+//#region scripts/dataStructure/constraint/fileExist.ts
+const fileExistConstraintKind = require_kind.createKind("file-exist-constraint");
+const FileExistConstraint = _duplojs_lang_dataStructure.createConstraint(fileExistConstraintKind, ({ init }) => () => init({}, {
 	executeCheck: async (_self, data) => {
 		const result = _duplojs_lang_either.rightPipe(await data.stat(), (stat) => stat.isFile ? stat : _duplojs_lang_either.fail());
 		if (_duplojs_lang_either.isLeft(result)) return _duplojs_lang_dataStructure.ErrorSymbol;
@@ -15,5 +15,5 @@ const ExistConstraint = _duplojs_lang_dataStructure.createConstraint(existConstr
 	isAsynchronous: () => true
 }));
 //#endregion
-exports.ExistConstraint = ExistConstraint;
-exports.existConstraintKind = existConstraintKind;
+exports.FileExistConstraint = FileExistConstraint;
+exports.fileExistConstraintKind = fileExistConstraintKind;

package/dist/dataStructure/constraint/fileExist.d.ts

@@ -0,0 +1,10 @@
+import type * as DCommon from "@duplojs/lang/common";
+import type * as DKind from "@duplojs/lang/kind";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import type * as DSFile from '../../file';
+export declare const fileExistConstraintKind: DKind.Handler<DKind.Definition<"@DuplojsServerDataStructure/file-exist-constraint", unknown>>;
+export interface FileExistConstraintDefinition extends DDataStructure.ConstraintDefinition {
+}
+export interface FileExistConstraint extends DCommon.UnionToIntersection<DDataStructure.Constraint<DSFile.FileInterface, DSFile.FileInterface, FileExistConstraintDefinition> & DKind.Kind<typeof fileExistConstraintKind>> {
+}
+export declare const FileExistConstraint: () => FileExistConstraint;