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

package/dist/common/getCurrentWorkDirectory.cjs

@@ -0,0 +1,15 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_implementor = require("../implementor.cjs");
+let _duplojs_lang_common = require("@duplojs/lang/common");
+_duplojs_lang_common = require_runtime.__toESM(_duplojs_lang_common, 1);
+let _duplojs_lang_either = require("@duplojs/lang/either");
+_duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
+let _duplojs_lang_path = require("@duplojs/lang/path");
+_duplojs_lang_path = require_runtime.__toESM(_duplojs_lang_path, 1);
+//#region scripts/common/getCurrentWorkDirectory.ts
+const getCurrentWorkDirectory = require_implementor.implementFunction("getCurrentWorkDirectory", {
+	NODE: () => _duplojs_lang_common.pipe(_duplojs_lang_either.safeCallback(() => _duplojs_lang_common.whenElse(_duplojs_lang_path.normalize(process.cwd()), (value) => _duplojs_lang_common.isType(value, "string") && _duplojs_lang_path.isAbsolute(value), _duplojs_lang_either.success, _duplojs_lang_either.error)), _duplojs_lang_either.whenIsLeft(_duplojs_lang_either.error)),
+	DENO: () => _duplojs_lang_common.pipe(_duplojs_lang_either.safeCallback(() => _duplojs_lang_common.whenElse(_duplojs_lang_path.normalize(Deno.cwd()), (value) => _duplojs_lang_common.isType(value, "string") && _duplojs_lang_path.isAbsolute(value), _duplojs_lang_either.success, _duplojs_lang_either.error)), _duplojs_lang_either.whenIsLeft(_duplojs_lang_either.error))
+});
+//#endregion
+exports.getCurrentWorkDirectory = getCurrentWorkDirectory;

package/dist/common/getCurrentWorkDirectory.d.ts

@@ -0,0 +1,8 @@
+import * as DEither from "@duplojs/lang/either";
+import * as DPath from "@duplojs/lang/path";
+declare module '../implementor' {
+    interface ServerFunction {
+        getCurrentWorkDirectory(): (DEither.Error<unknown> | DEither.Success<string & DPath.Absolute>);
+    }
+}
+export declare const getCurrentWorkDirectory: () => (DEither.Error<unknown> | DEither.Success<string & DPath.Absolute>);

package/dist/common/getCurrentWorkDirectory.mjs

@@ -0,0 +1,11 @@
+import { implementFunction } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+import * as DPath from "@duplojs/lang/path";
+//#region scripts/common/getCurrentWorkDirectory.ts
+const getCurrentWorkDirectory = implementFunction("getCurrentWorkDirectory", {
+	NODE: () => DCommon.pipe(DEither.safeCallback(() => DCommon.whenElse(DPath.normalize(process.cwd()), (value) => DCommon.isType(value, "string") && DPath.isAbsolute(value), DEither.success, DEither.error)), DEither.whenIsLeft(DEither.error)),
+	DENO: () => DCommon.pipe(DEither.safeCallback(() => DCommon.whenElse(DPath.normalize(Deno.cwd()), (value) => DCommon.isType(value, "string") && DPath.isAbsolute(value), DEither.success, DEither.error)), DEither.whenIsLeft(DEither.error))
+});
+//#endregion
+export { getCurrentWorkDirectory };

package/dist/common/getCurrentWorkDirectoryOrThrow.cjs

@@ -0,0 +1,25 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_getCurrentWorkDirectory = require("./getCurrentWorkDirectory.cjs");
+const require_kind = require("../kind.cjs");
+let _duplojs_lang_common = require("@duplojs/lang/common");
+_duplojs_lang_common = require_runtime.__toESM(_duplojs_lang_common, 1);
+let _duplojs_lang_either = require("@duplojs/lang/either");
+_duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
+let _duplojs_lang_kind = require("@duplojs/lang/kind");
+_duplojs_lang_kind = require_runtime.__toESM(_duplojs_lang_kind, 1);
+//#region scripts/common/getCurrentWorkDirectoryOrThrow.ts
+var GetCurrentWorkDirectoryError = class extends _duplojs_lang_kind.parentClass(require_kind.createKind("environment-variable-error"), Error) {
+	error;
+	constructor(error) {
+		super(null, "Failed to retrieve the current directory path.");
+		this.error = error;
+	}
+};
+function getCurrentWorkDirectoryOrThrow() {
+	return _duplojs_lang_either.whenIsRightOtherwise(require_getCurrentWorkDirectory.getCurrentWorkDirectory(), _duplojs_lang_common.forward, (result) => {
+		throw new GetCurrentWorkDirectoryError(_duplojs_lang_either.unwrapLeft(result));
+	});
+}
+//#endregion
+exports.GetCurrentWorkDirectoryError = GetCurrentWorkDirectoryError;
+exports.getCurrentWorkDirectoryOrThrow = getCurrentWorkDirectoryOrThrow;

package/dist/common/getCurrentWorkDirectoryOrThrow.d.ts

@@ -0,0 +1,8 @@
+import * as DKind from "@duplojs/lang/kind";
+declare const GetCurrentWorkDirectoryError_base: DKind.KindClass<DKind.Handler<DKind.Definition<"@DuplojsServer/environment-variable-error", unknown>>, ErrorConstructor>;
+export declare class GetCurrentWorkDirectoryError extends GetCurrentWorkDirectoryError_base {
+    error: unknown;
+    constructor(error: unknown);
+}
+export declare function getCurrentWorkDirectoryOrThrow(): string & import('@duplojs/lang/path').Absolute;
+export {};

package/dist/common/getCurrentWorkDirectoryOrThrow.mjs

@@ -0,0 +1,20 @@
+import { getCurrentWorkDirectory } from "./getCurrentWorkDirectory.mjs";
+import { createKind } from "../kind.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+import * as DKind from "@duplojs/lang/kind";
+//#region scripts/common/getCurrentWorkDirectoryOrThrow.ts
+var GetCurrentWorkDirectoryError = class extends DKind.parentClass(createKind("environment-variable-error"), Error) {
+	error;
+	constructor(error) {
+		super(null, "Failed to retrieve the current directory path.");
+		this.error = error;
+	}
+};
+function getCurrentWorkDirectoryOrThrow() {
+	return DEither.whenIsRightOtherwise(getCurrentWorkDirectory(), DCommon.forward, (result) => {
+		throw new GetCurrentWorkDirectoryError(DEither.unwrapLeft(result));
+	});
+}
+//#endregion
+export { GetCurrentWorkDirectoryError, getCurrentWorkDirectoryOrThrow };

package/dist/common/getProcessArguments.cjs

@@ -0,0 +1,18 @@
+const require_implementor = require("../implementor.cjs");
+//#region scripts/common/getProcessArguments.ts
+let args = void 0;
+const getProcessArguments = require_implementor.implementFunction("getProcessArguments", {
+	NODE: () => {
+		if (args) return args;
+		args = process.argv.slice(2);
+		return args;
+	},
+	DENO: () => Deno.args,
+	BUN: () => {
+		if (args) return args;
+		args = Bun.argv.slice(2);
+		return args;
+	}
+});
+//#endregion
+exports.getProcessArguments = getProcessArguments;

package/dist/common/getProcessArguments.d.ts

@@ -0,0 +1,6 @@
+declare module '../implementor' {
+    interface ServerFunction {
+        getProcessArguments(): string[];
+    }
+}
+export declare const getProcessArguments: () => string[];

package/dist/common/getProcessArguments.mjs

@@ -0,0 +1,18 @@
+import { implementFunction } from "../implementor.mjs";
+//#region scripts/common/getProcessArguments.ts
+let args = void 0;
+const getProcessArguments = implementFunction("getProcessArguments", {
+	NODE: () => {
+		if (args) return args;
+		args = process.argv.slice(2);
+		return args;
+	},
+	DENO: () => Deno.args,
+	BUN: () => {
+		if (args) return args;
+		args = Bun.argv.slice(2);
+		return args;
+	}
+});
+//#endregion
+export { getProcessArguments };

package/dist/common/index.cjs

@@ -0,0 +1,44 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_getCurrentWorkDirectory = require("./getCurrentWorkDirectory.cjs");
+const require_getCurrentWorkDirectoryOrThrow = require("./getCurrentWorkDirectoryOrThrow.cjs");
+const require_setCurrentWorkingDirectory = require("./setCurrentWorkingDirectory.cjs");
+const require_setCurrentWorkingDirectoryOrThrow = require("./setCurrentWorkingDirectoryOrThrow.cjs");
+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,
+	GetCurrentWorkDirectoryError: () => require_getCurrentWorkDirectoryOrThrow.GetCurrentWorkDirectoryError,
+	SetCurrentWorkingDirectoryError: () => require_setCurrentWorkingDirectoryOrThrow.SetCurrentWorkingDirectoryError,
+	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,
+	setCurrentWorkingDirectory: () => require_setCurrentWorkingDirectory.setCurrentWorkingDirectory,
+	setCurrentWorkingDirectoryOrThrow: () => require_setCurrentWorkingDirectoryOrThrow.setCurrentWorkingDirectoryOrThrow
+});
+//#endregion
+exports.EnvironmentVariableError = require_environmentVariableOrThrow.EnvironmentVariableError;
+exports.GetCurrentWorkDirectoryError = require_getCurrentWorkDirectoryOrThrow.GetCurrentWorkDirectoryError;
+exports.SetCurrentWorkingDirectoryError = require_setCurrentWorkingDirectoryOrThrow.SetCurrentWorkingDirectoryError;
+Object.defineProperty(exports, "common_exports", {
+	enumerable: true,
+	get: function() {
+		return 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;
+exports.setCurrentWorkingDirectory = require_setCurrentWorkingDirectory.setCurrentWorkingDirectory;
+exports.setCurrentWorkingDirectoryOrThrow = require_setCurrentWorkingDirectoryOrThrow.setCurrentWorkingDirectoryOrThrow;

package/dist/common/index.d.ts

@@ -0,0 +1,9 @@
+export * from './getCurrentWorkDirectory';
+export * from './getCurrentWorkDirectoryOrThrow';
+export * from './setCurrentWorkingDirectory';
+export * from './setCurrentWorkingDirectoryOrThrow';
+export * from './environmentVariable';
+export * from './environmentVariableOrThrow';
+export * from './exitProcess';
+export * from './getProcessArguments';
+export * from './meta';

package/dist/common/index.mjs

@@ -0,0 +1,27 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
+import { getCurrentWorkDirectory } from "./getCurrentWorkDirectory.mjs";
+import { GetCurrentWorkDirectoryError, getCurrentWorkDirectoryOrThrow } from "./getCurrentWorkDirectoryOrThrow.mjs";
+import { setCurrentWorkingDirectory } from "./setCurrentWorkingDirectory.mjs";
+import { SetCurrentWorkingDirectoryError, setCurrentWorkingDirectoryOrThrow } from "./setCurrentWorkingDirectoryOrThrow.mjs";
+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,
+	GetCurrentWorkDirectoryError: () => GetCurrentWorkDirectoryError,
+	SetCurrentWorkingDirectoryError: () => SetCurrentWorkingDirectoryError,
+	environmentVariable: () => environmentVariable,
+	environmentVariableOrThrow: () => environmentVariableOrThrow,
+	exitProcess: () => exitProcess,
+	getCurrentDirectoryName: () => getCurrentDirectoryName,
+	getCurrentWorkDirectory: () => getCurrentWorkDirectory,
+	getCurrentWorkDirectoryOrThrow: () => getCurrentWorkDirectoryOrThrow,
+	getProcessArguments: () => getProcessArguments,
+	setCurrentWorkingDirectory: () => setCurrentWorkingDirectory,
+	setCurrentWorkingDirectoryOrThrow: () => setCurrentWorkingDirectoryOrThrow
+});
+//#endregion
+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/common/setCurrentWorkingDirectory.cjs

@@ -0,0 +1,11 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_implementor = require("../implementor.cjs");
+let _duplojs_lang_either = require("@duplojs/lang/either");
+_duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
+//#region scripts/common/setCurrentWorkingDirectory.ts
+const setCurrentWorkingDirectory = require_implementor.implementFunction("setCurrentWorkingDirectory", {
+	NODE: (path) => _duplojs_lang_either.whenIsRightOtherwise(_duplojs_lang_either.safeCallback(() => void process.chdir(path)), _duplojs_lang_either.ok, _duplojs_lang_either.fail),
+	DENO: (path) => _duplojs_lang_either.whenIsRightOtherwise(_duplojs_lang_either.safeCallback(() => void Deno.chdir(path)), _duplojs_lang_either.ok, _duplojs_lang_either.fail)
+});
+//#endregion
+exports.setCurrentWorkingDirectory = setCurrentWorkingDirectory;

package/dist/common/setCurrentWorkingDirectory.d.ts

@@ -0,0 +1,8 @@
+import * as DEither from "@duplojs/lang/either";
+import type * as DPath from "@duplojs/lang/path";
+declare module '../implementor' {
+    interface ServerFunction {
+        setCurrentWorkingDirectory(path: string & DPath.Absolute): DEither.Fail | DEither.Ok;
+    }
+}
+export declare const setCurrentWorkingDirectory: (path: string & DPath.Absolute) => DEither.Fail | DEither.Ok;

package/dist/common/setCurrentWorkingDirectory.mjs

@@ -0,0 +1,9 @@
+import { implementFunction } from "../implementor.mjs";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/common/setCurrentWorkingDirectory.ts
+const setCurrentWorkingDirectory = implementFunction("setCurrentWorkingDirectory", {
+	NODE: (path) => DEither.whenIsRightOtherwise(DEither.safeCallback(() => void process.chdir(path)), DEither.ok, DEither.fail),
+	DENO: (path) => DEither.whenIsRightOtherwise(DEither.safeCallback(() => void Deno.chdir(path)), DEither.ok, DEither.fail)
+});
+//#endregion
+export { setCurrentWorkingDirectory };

package/dist/common/setCurrentWorkingDirectoryOrThrow.cjs

@@ -0,0 +1,23 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_kind = require("../kind.cjs");
+const require_setCurrentWorkingDirectory = require("./setCurrentWorkingDirectory.cjs");
+let _duplojs_lang_common = require("@duplojs/lang/common");
+_duplojs_lang_common = require_runtime.__toESM(_duplojs_lang_common, 1);
+let _duplojs_lang_either = require("@duplojs/lang/either");
+_duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
+let _duplojs_lang_kind = require("@duplojs/lang/kind");
+_duplojs_lang_kind = require_runtime.__toESM(_duplojs_lang_kind, 1);
+//#region scripts/common/setCurrentWorkingDirectoryOrThrow.ts
+var SetCurrentWorkingDirectoryError = class extends _duplojs_lang_kind.parentClass(require_kind.createKind("set-working-directory-error"), Error) {
+	constructor() {
+		super({}, "Failed to set current working directory");
+	}
+};
+function setCurrentWorkingDirectoryOrThrow(path) {
+	_duplojs_lang_either.whenIsRightOtherwise(require_setCurrentWorkingDirectory.setCurrentWorkingDirectory(path), _duplojs_lang_common.forward, () => {
+		throw new SetCurrentWorkingDirectoryError();
+	});
+}
+//#endregion
+exports.SetCurrentWorkingDirectoryError = SetCurrentWorkingDirectoryError;
+exports.setCurrentWorkingDirectoryOrThrow = setCurrentWorkingDirectoryOrThrow;

package/dist/common/setCurrentWorkingDirectoryOrThrow.d.ts

@@ -0,0 +1,8 @@
+import * as DKind from "@duplojs/lang/kind";
+import type * as DPath from "@duplojs/lang/path";
+declare const SetCurrentWorkingDirectoryError_base: DKind.KindClass<DKind.Handler<DKind.Definition<"@DuplojsServer/set-working-directory-error", unknown>>, ErrorConstructor>;
+export declare class SetCurrentWorkingDirectoryError extends SetCurrentWorkingDirectoryError_base {
+    constructor();
+}
+export declare function setCurrentWorkingDirectoryOrThrow(path: string & DPath.Absolute): void;
+export {};

package/dist/common/setCurrentWorkingDirectoryOrThrow.mjs

@@ -0,0 +1,18 @@
+import { createKind } from "../kind.mjs";
+import { setCurrentWorkingDirectory } from "./setCurrentWorkingDirectory.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+import * as DKind from "@duplojs/lang/kind";
+//#region scripts/common/setCurrentWorkingDirectoryOrThrow.ts
+var SetCurrentWorkingDirectoryError = class extends DKind.parentClass(createKind("set-working-directory-error"), Error) {
+	constructor() {
+		super({}, "Failed to set current working directory");
+	}
+};
+function setCurrentWorkingDirectoryOrThrow(path) {
+	DEither.whenIsRightOtherwise(setCurrentWorkingDirectory(path), DCommon.forward, () => {
+		throw new SetCurrentWorkingDirectoryError();
+	});
+}
+//#endregion
+export { SetCurrentWorkingDirectoryError, setCurrentWorkingDirectoryOrThrow };

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

@@ -0,0 +1,2 @@
+export * from './json';
+export * from './string';

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

@@ -0,0 +1,25 @@
+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");
+_duplojs_lang_dataStructure = require_runtime.__toESM(_duplojs_lang_dataStructure, 1);
+//#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", (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

@@ -0,0 +1,9 @@
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import * as FundamentalType from "../../../fundamentalType";
+export declare const codecsJson: DDataStructure.Codecs<{
+    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

@@ -0,0 +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", (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

@@ -0,0 +1,25 @@
+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");
+_duplojs_lang_dataStructure = require_runtime.__toESM(_duplojs_lang_dataStructure, 1);
+//#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", (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

@@ -0,0 +1,13 @@
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import * as FundamentalType from "../../../fundamentalType";
+export declare const codecsString: DDataStructure.Codecs<{
+    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>;
+    null: import('@duplojs/lang/dataStructure').Codec<DDataStructure.TheNull, "null">;
+    number: import('@duplojs/lang/dataStructure').Codec<DDataStructure.TheNumber, string & import('@duplojs/lang/string').Number>;
+    time: import('@duplojs/lang/dataStructure').Codec<DDataStructure.TheTime, string>;
+    undefined: import('@duplojs/lang/dataStructure').Codec<DDataStructure.TheUndefined, "undefined" | undefined>;
+}>;

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

@@ -0,0 +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", (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/codec/index.d.ts

@@ -0,0 +1 @@
+export * from './defaults';

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

@@ -0,0 +1,29 @@
+const require_runtime = require("../../../_virtual/_rolldown/runtime.cjs");
+const require_json = require("../codec/defaults/json.cjs");
+let _duplojs_lang_dataStructure = require("@duplojs/lang/dataStructure");
+_duplojs_lang_dataStructure = require_runtime.__toESM(_duplojs_lang_dataStructure, 1);
+//#region scripts/dataStructure/common/error/defaultInterpreter.ts
+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.`;
+		if (min !== void 0) return `Expected a file size of at least ${min} bytes.`;
+		if (max !== void 0) return `Expected a file size of at most ${max} bytes.`;
+		return "Expected a valid file size.";
+	},
+	"@DuplojsServerDataStructure/mime-type-constraint": (source) => `Expected a file with a MIME type matching ${source.definition.regex.toString()}.`,
+	"@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.";
+	if (issue.from === "encoding") return "The JSON file codec could not encode the file.";
+	if (issue.from === "decoding") return "The JSON file codec could not decode the value as a file.";
+	return `The JSON file codec encountered an external error while ${_duplojs_lang_dataStructure.encodeIssueKind.has(issue) ? "encoding" : "decoding"}.`;
+}]];
+//#endregion
+exports.defaultErrorInterpreterCodecDictionary = defaultErrorInterpreterCodecDictionary;
+exports.defaultErrorInterpreterDataStructureDictionary = defaultErrorInterpreterDataStructureDictionary;

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

@@ -0,0 +1,69 @@
+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/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;
+    readonly "@DuplojsLangDataStructure/object-structure": () => string;
+    readonly "@DuplojsLangDataStructure/record-structure": () => string;
+    readonly "@DuplojsLangDataStructure/type-structure": () => string;
+    readonly "@DuplojsLangDataStructure/union-structure": () => string;
+    readonly "@DuplojsLangDataStructure/bigint-type": () => string;
+    readonly "@DuplojsLangDataStructure/bigint-literal-type": (source: import('@duplojs/lang/dataStructure').BigintLiteralType<bigint>) => string;
+    readonly "@DuplojsLangDataStructure/boolean-type": () => string;
+    readonly "@DuplojsLangDataStructure/boolean-literal-type": (source: import('@duplojs/lang/dataStructure').BooleanLiteralType<boolean>) => string;
+    readonly "@DuplojsLangDataStructure/date-type": () => string;
+    readonly "@DuplojsLangDataStructure/null-type": () => string;
+    readonly "@DuplojsLangDataStructure/number-type": () => string;
+    readonly "@DuplojsLangDataStructure/number-literal-type": (source: import('@duplojs/lang/dataStructure').NumberLiteralType<number>) => string;
+    readonly "@DuplojsLangDataStructure/string-type": () => string;
+    readonly "@DuplojsLangDataStructure/string-literal-type": (source: import('@duplojs/lang/dataStructure').StringLiteralType<string>) => string;
+    readonly "@DuplojsLangDataStructure/time-type": () => string;
+    readonly "@DuplojsLangDataStructure/undefined-type": () => string;
+    readonly "@DuplojsLangDataStructure/absolute-path-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/allowed-characters-constraint": (source: import('@duplojs/lang/dataStructure').AllowedCharactersConstraint<import('@duplojs/lang/string').CharactersRange>) => string;
+    readonly "@DuplojsLangDataStructure/array-length-equal-constraint": (source: import('@duplojs/lang/dataStructure').ArrayLengthEqualConstraint<number>) => string;
+    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;
+    readonly "@DuplojsLangDataStructure/max-characters-constraint": (source: import('@duplojs/lang/dataStructure').MaxCharactersConstraint<number>) => string;
+    readonly "@DuplojsLangDataStructure/max-elements-constraint": (source: import('@duplojs/lang/dataStructure').MaxElementsConstraint<number>) => string;
+    readonly "@DuplojsLangDataStructure/min-characters-constraint": (source: import('@duplojs/lang/dataStructure').MinCharactersConstraint<number>) => string;
+    readonly "@DuplojsLangDataStructure/min-elements-constraint": (source: import('@duplojs/lang/dataStructure').MinElementsConstraint<number>) => string;
+    readonly "@DuplojsLangDataStructure/multiple-of-constraint": (source: import('@duplojs/lang/dataStructure').MultipleOfConstraint<number>) => string;
+    readonly "@DuplojsLangDataStructure/negative-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/not-empty-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/not-zero-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/number-in-string-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/odd-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/path-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/positive-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/refine-constraint": () => string;
+    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;
+    readonly "@DuplojsLangDataStructure/trimmed-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/url-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/uuid-constraint": () => string;
+    readonly "@DuplojsLangModeling/entity-structure": () => string;
+    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>, (_codec: DDataStructure.Codec<DDataStructure.FundamentalType<unknown>, unknown>, issue: DDataStructure.EncodeIssue | DDataStructure.DecodeIssue) => string]];