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

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,41 @@
+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");
+//#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,
+	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.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,8 @@
+export * from './getCurrentWorkDirectory';
+export * from './getCurrentWorkDirectoryOrThrow';
+export * from './setCurrentWorkingDirectory';
+export * from './setCurrentWorkingDirectoryOrThrow';
+export * from './environmentVariable';
+export * from './environmentVariableOrThrow';
+export * from './exitProcess';
+export * from './getProcessArguments';

package/dist/common/index.mjs

@@ -0,0 +1,25 @@
+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";
+//#region scripts/common/index.ts
+var common_exports = /* @__PURE__ */ __exportAll({
+	EnvironmentVariableError: () => EnvironmentVariableError,
+	GetCurrentWorkDirectoryError: () => GetCurrentWorkDirectoryError,
+	SetCurrentWorkingDirectoryError: () => SetCurrentWorkingDirectoryError,
+	environmentVariable: () => environmentVariable,
+	environmentVariableOrThrow: () => environmentVariableOrThrow,
+	exitProcess: () => exitProcess,
+	getCurrentWorkDirectory: () => getCurrentWorkDirectory,
+	getCurrentWorkDirectoryOrThrow: () => getCurrentWorkDirectoryOrThrow,
+	getProcessArguments: () => getProcessArguments,
+	setCurrentWorkingDirectory: () => setCurrentWorkingDirectory,
+	setCurrentWorkingDirectoryOrThrow: () => setCurrentWorkingDirectoryOrThrow
+});
+//#endregion
+export { EnvironmentVariableError, GetCurrentWorkDirectoryError, SetCurrentWorkingDirectoryError, common_exports, environmentVariable, environmentVariableOrThrow, exitProcess, getCurrentWorkDirectory, getCurrentWorkDirectoryOrThrow, getProcessArguments, setCurrentWorkingDirectory, setCurrentWorkingDirectoryOrThrow };

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,14 @@
+const require_runtime = require("../../../../_virtual/_rolldown/runtime.cjs");
+const require_fileInterface = require("../../../../file/fileInterface.cjs");
+const require_file = require("../../../fundamentalType/file.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" && _duplojs_lang_path.is(data), (data) => data.path, (data) => require_fileInterface.createFileInterface(data))
+});
+//#endregion
+exports.codecsJson = codecsJson;

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

@@ -0,0 +1,9 @@
+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>;
+    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,11 @@
+import { createFileInterface } from "../../../../file/fileInterface.mjs";
+import { TheFile } from "../../../fundamentalType/file.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))
+});
+//#endregion
+export { codecsJson };

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

@@ -0,0 +1,14 @@
+const require_runtime = require("../../../../_virtual/_rolldown/runtime.cjs");
+const require_fileInterface = require("../../../../file/fileInterface.cjs");
+const require_file = require("../../../fundamentalType/file.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" && _duplojs_lang_path.is(data), (data) => data.path, (data) => require_fileInterface.createFileInterface(data))
+});
+//#endregion
+exports.codecsString = codecsString;

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

@@ -0,0 +1,13 @@
+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>;
+    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,11 @@
+import { createFileInterface } from "../../../../file/fileInterface.mjs";
+import { TheFile } from "../../../fundamentalType/file.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))
+});
+//#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,27 @@
+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/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/exist-constraint": () => "Expected the file 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,64 @@
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+export declare const defaultErrorInterpreterDataStructureDictionary: {
+    readonly "@DuplojsServerDataStructure/file-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 "@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/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/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/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 & import('@duplojs/lang/path').Path>, (_codec: DDataStructure.Codec<DDataStructure.FundamentalType<unknown>, unknown>, issue: DDataStructure.EncodeIssue | DDataStructure.DecodeIssue) => string]];

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

@@ -0,0 +1,24 @@
+import { codecsJson } from "../codec/defaults/json.mjs";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+//#region scripts/dataStructure/common/error/defaultInterpreter.ts
+const defaultErrorInterpreterDataStructureDictionary = {
+	...DDataStructure.defaultErrorInterpreterDataStructureDictionary,
+	"@DuplojsServerDataStructure/file-type": () => "Expected a valid file.",
+	"@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/exist-constraint": () => "Expected the file 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.";
+	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 ${DDataStructure.encodeIssueKind.has(issue) ? "encoding" : "decoding"}.`;
+}]];
+//#endregion
+export { defaultErrorInterpreterCodecDictionary, defaultErrorInterpreterDataStructureDictionary };

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

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

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

@@ -0,0 +1,2 @@
+export * from './codec';
+export * from './error';

package/dist/dataStructure/constraint/exist.cjs

@@ -0,0 +1,19 @@
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+const require_kind = require("../kind.cjs");
+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({}, {
+	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;
+		return _duplojs_lang_dataStructure.SuccessSymbol;
+	},
+	isAsynchronous: () => true
+}));
+//#endregion
+exports.ExistConstraint = ExistConstraint;
+exports.existConstraintKind = existConstraintKind;

package/dist/dataStructure/constraint/exist.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 existConstraintKind: DKind.Handler<DKind.Definition<"@DuplojsServerDataStructure/exist-constraint", unknown>>;
+export interface ExistConstraintDefinition extends DDataStructure.ConstraintDefinition {
+}
+export interface ExistConstraint extends DCommon.UnionToIntersection<DDataStructure.Constraint<DSFile.FileInterface, DSFile.FileInterface, ExistConstraintDefinition> & DKind.Kind<typeof existConstraintKind>> {
+}
+export declare const ExistConstraint: () => ExistConstraint;

package/dist/dataStructure/constraint/exist.mjs

@@ -0,0 +1,15 @@
+import { createKind } from "../kind.mjs";
+import * as DEither from "@duplojs/lang/either";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+//#region scripts/dataStructure/constraint/exist.ts
+const existConstraintKind = createKind("exist-constraint");
+const ExistConstraint = DDataStructure.createConstraint(existConstraintKind, ({ init }) => () => init({}, {
+	executeCheck: async (_self, data) => {
+		const result = DEither.rightPipe(await data.stat(), (stat) => stat.isFile ? stat : DEither.fail());
+		if (DEither.isLeft(result)) return DDataStructure.ErrorSymbol;
+		return DDataStructure.SuccessSymbol;
+	},
+	isAsynchronous: () => true
+}));
+//#endregion
+export { ExistConstraint, existConstraintKind };

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

@@ -0,0 +1,4 @@
+export * from './exist';
+export * from './mimeType';
+export * from './size';
+export type * from './types';

package/dist/dataStructure/constraint/mimeType.cjs

@@ -0,0 +1,18 @@
+const require_runtime = require("../../_virtual/_rolldown/runtime.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_dataStructure = require("@duplojs/lang/dataStructure");
+_duplojs_lang_dataStructure = require_runtime.__toESM(_duplojs_lang_dataStructure, 1);
+//#region scripts/dataStructure/constraint/mimeType.ts
+const mimeTypeConstraintKind = require_kind.createKind("mime-type-constraint");
+const MimeTypeConstraint = _duplojs_lang_dataStructure.createConstraint(mimeTypeConstraintKind, ({ init }) => (mimeType) => init({ regex: _duplojs_lang_common.toRegExp(mimeType) }, {
+	executeCheck: (self, data) => {
+		if (self.definition.regex.test(data.getMimeType() ?? "")) return _duplojs_lang_dataStructure.ErrorSymbol;
+		return _duplojs_lang_dataStructure.SuccessSymbol;
+	},
+	isAsynchronous: () => false
+}));
+//#endregion
+exports.MimeTypeConstraint = MimeTypeConstraint;
+exports.mimeTypeConstraintKind = mimeTypeConstraintKind;

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

@@ -0,0 +1,11 @@
+import * 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 mimeTypeConstraintKind: DKind.Handler<DKind.Definition<"@DuplojsServerDataStructure/mime-type-constraint", unknown>>;
+export interface MimeTypeConstraintDefinition extends DDataStructure.ConstraintDefinition {
+    regex: RegExp;
+}
+export interface MimeTypeConstraint extends DCommon.UnionToIntersection<DDataStructure.Constraint<DSFile.FileInterface, DSFile.FileInterface, MimeTypeConstraintDefinition> & DKind.Kind<typeof mimeTypeConstraintKind>> {
+}
+export declare const MimeTypeConstraint: (mimeType: Parameters<typeof DCommon.toRegExp>[0]) => MimeTypeConstraint;

package/dist/dataStructure/constraint/mimeType.mjs

@@ -0,0 +1,14 @@
+import { createKind } from "../kind.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+//#region scripts/dataStructure/constraint/mimeType.ts
+const mimeTypeConstraintKind = createKind("mime-type-constraint");
+const MimeTypeConstraint = DDataStructure.createConstraint(mimeTypeConstraintKind, ({ init }) => (mimeType) => init({ regex: DCommon.toRegExp(mimeType) }, {
+	executeCheck: (self, data) => {
+		if (self.definition.regex.test(data.getMimeType() ?? "")) return DDataStructure.ErrorSymbol;
+		return DDataStructure.SuccessSymbol;
+	},
+	isAsynchronous: () => false
+}));
+//#endregion
+export { MimeTypeConstraint, mimeTypeConstraintKind };