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

package/dist/command/argument.d.ts

@@ -1,5 +1,5 @@
 import { Error, SymbolCommandError } from './error';
-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";
@@ -15,4 +15,4 @@ export interface CreateArgumentParams {
     readonly description?: string;
     readonly optional?: boolean;
 }
-export declare function createArgument<GenericName extends string, GenericStructure extends DDataStructure.Structure<EligibleType>, GenericValue extends DDataStructure.StructureValue<GenericStructure>, const GenericParams extends CreateArgumentParams = {}>(name: GenericName, dataStructure: GenericStructure, params?: GenericParams): Argument<GenericName, (GenericValue | (DCommon.IsEqual<GenericParams["optional"], true> extends true ? undefined : never))>;
+export declare function createArgument<GenericName extends string, GenericStructure extends DDataStructure.Structure<EligibleType>, GenericValue extends DDataStructure.StructureValue<GenericStructure>, const GenericParams extends CreateArgumentParams = {}>(name: GenericName & ForbiddenInvalidIdentifier<GenericName>, dataStructure: GenericStructure, params?: GenericParams): Argument<GenericName, (GenericValue | (DCommon.IsEqual<GenericParams["optional"], true> extends true ? undefined : never))>;

package/dist/command/create.cjs

@@ -1,6 +1,7 @@
 const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
 const require_kind = require("./kind.cjs");
 const require_error = require("./error.cjs");
+const require_base = require("./options/base.cjs");
 const require_help = require("./help.cjs");
 let _duplojs_lang_common = require("@duplojs/lang/common");
 _duplojs_lang_common = require_runtime.__toESM(_duplojs_lang_common, 1);
@@ -63,6 +64,8 @@ function create(...args) {
 				});
 			});
 			if (commandOptions.hasError === true) return require_error.SymbolCommandError;
+			const unknownOptions = _duplojs_lang_array.filter(commandOptions.restArgs, require_base.isOptionToken);
+			if (unknownOptions.length > 0) return error.addUnknownOptionIssue(unknownOptions);
 			if (self.subject?.type === "argument") {
 				if (self.subject.args.length < commandOptions.restArgs.length) return error.addTooMuchCommandArgumentIssue(self.subject.args.length, commandOptions.restArgs.length);
 				const commandArgs = await _duplojs_lang_generator.asyncReduce(self.subject.args, _duplojs_lang_generator.reduceFrom({
@@ -83,7 +86,10 @@ function create(...args) {
 					args: commandArgs.args
 				});
 			} else {
-				if (commandOptions.restArgs.length > 0) return error.addTooMuchCommandArgumentIssue(0, commandOptions.restArgs.length);
+				if (commandOptions.restArgs.length > 0) {
+					if (self.subject?.type === "subCommand") return error.addUnknownSubCommandIssue(commandOptions.restArgs[0]);
+					return error.addTooMuchCommandArgumentIssue(0, commandOptions.restArgs.length);
+				}
 				await execute({ options: commandOptions.options });
 			}
 		},

package/dist/command/create.d.ts

@@ -1,7 +1,7 @@
 import { Option } from './options';
 import { SymbolCommandError, Error } from './error';
 import { Argument } from './argument';
-import { ForbiddenDuplicateName } from './types';
+import { ForbiddenDuplicateName, ForbiddenInvalidIdentifier } from './types';
 import * as DCommon from "@duplojs/lang/common";
 import type * as DKind from "@duplojs/lang/kind";
 declare const commandKind: DKind.Handler<DKind.Definition<"@DuplojsServerCommand/command", unknown>>;
@@ -42,6 +42,6 @@ export type CreateCommandExecuteParams<GenericOptions extends DCommon.AnyTuple<O
         readonly [GenericArgument in GenericArguments[number] as GenericArgument["name"]]: Exclude<Awaited<ReturnType<GenericArgument["execute"]>>, SymbolCommandError>;
     };
 }));
-export declare function create<GenericName extends string>(name: GenericName, execute: () => void): Command<GenericName>;
-export declare function create<GenericName extends string, const GenericOptions extends DCommon.AnyTuple<Option> = never, GenericSubjects extends Subjects = never>(name: GenericName, params: CreateCommandParams<GenericOptions, GenericSubjects>, execute: (params: CreateCommandExecuteParams<GenericOptions, Extract<GenericSubjects, DCommon.AnyTuple<Argument>>>) => DCommon.MaybePromise<void>): Command<GenericName>;
+export declare function create<GenericName extends string>(name: GenericName & ForbiddenInvalidIdentifier<GenericName>, execute: () => void): Command<GenericName>;
+export declare function create<GenericName extends string, const GenericOptions extends DCommon.AnyTuple<Option> = never, GenericSubjects extends Subjects = never>(name: GenericName & ForbiddenInvalidIdentifier<GenericName>, params: CreateCommandParams<GenericOptions, GenericSubjects>, execute: (params: CreateCommandExecuteParams<GenericOptions, Extract<GenericSubjects, DCommon.AnyTuple<Argument>>>) => DCommon.MaybePromise<void>): Command<GenericName>;
 export {};

package/dist/command/create.mjs

@@ -1,5 +1,6 @@
 import { createKind } from "./kind.mjs";
 import { SymbolCommandError } from "./error.mjs";
+import { isOptionToken } from "./options/base.mjs";
 import { helpOption, logCommandHelp } from "./help.mjs";
 import * as DCommon from "@duplojs/lang/common";
 import * as DObject from "@duplojs/lang/object";
@@ -58,6 +59,8 @@ function create(...args) {
 				});
 			});
 			if (commandOptions.hasError === true) return SymbolCommandError;
+			const unknownOptions = DArray.filter(commandOptions.restArgs, isOptionToken);
+			if (unknownOptions.length > 0) return error.addUnknownOptionIssue(unknownOptions);
 			if (self.subject?.type === "argument") {
 				if (self.subject.args.length < commandOptions.restArgs.length) return error.addTooMuchCommandArgumentIssue(self.subject.args.length, commandOptions.restArgs.length);
 				const commandArgs = await DGenerator.asyncReduce(self.subject.args, DGenerator.reduceFrom({
@@ -78,7 +81,10 @@ function create(...args) {
 					args: commandArgs.args
 				});
 			} else {
-				if (commandOptions.restArgs.length > 0) return error.addTooMuchCommandArgumentIssue(0, commandOptions.restArgs.length);
+				if (commandOptions.restArgs.length > 0) {
+					if (self.subject?.type === "subCommand") return error.addUnknownSubCommandIssue(commandOptions.restArgs[0]);
+					return error.addTooMuchCommandArgumentIssue(0, commandOptions.restArgs.length);
+				}
 				await execute({ options: commandOptions.options });
 			}
 		},

package/dist/command/error.cjs

@@ -23,6 +23,20 @@ function createError(commandName) {
 		issues,
 		currentPath,
 		pushPath: (path) => void currentPath.push(path),
+		addUnknownOptionIssue: (optionTokens) => {
+			issues.push(_duplojs_lang_modeling.taggedObject("UnknownOptionIssue", {
+				optionTokens,
+				path: _duplojs_lang_string.join(currentPath, ".")
+			}));
+			return SymbolCommandError;
+		},
+		addUnknownSubCommandIssue: (subCommandName) => {
+			issues.push(_duplojs_lang_modeling.taggedObject("UnknownSubCommandIssue", {
+				subCommandName,
+				path: _duplojs_lang_string.join(currentPath, ".")
+			}));
+			return SymbolCommandError;
+		},
 		addRequiredOptionIssue: (optionName) => {
 			issues.push(_duplojs_lang_modeling.taggedObject("RequiredOptionIssue", {
 				optionName,
@@ -94,6 +108,16 @@ function interpretDataStructureError(error, dataStructureErrorInterpreter) {
 }
 function interpretErrorIssues(issues, dataStructureErrorInterpreter) {
 	return _duplojs_lang_printer.renderParagraph([_duplojs_lang_array.map(issues, _duplojs_lang_pattern.matchWithTaggedObject({
+		UnknownOptionIssue: ({ optionTokens }) => [_duplojs_lang_printer.render([
+			_duplojs_lang_printer.indent(1),
+			_duplojs_lang_printer.colorizedBold("OPTION: ", "blue"),
+			_duplojs_lang_string.join(optionTokens, ", ")
+		], ""), `${_duplojs_lang_printer.indent(1)}↳ Unknown Option`],
+		UnknownSubCommandIssue: ({ subCommandName }) => [_duplojs_lang_printer.render([
+			_duplojs_lang_printer.indent(1),
+			_duplojs_lang_printer.colorizedBold("SUB-COMMAND: ", "cyan"),
+			subCommandName
+		], ""), `${_duplojs_lang_printer.indent(1)}↳ Unknown Sub-command`],
 		DataStructureArgumentIssue: ({ argumentName, dataStructureError }) => [_duplojs_lang_printer.render([
 			_duplojs_lang_printer.indent(1),
 			_duplojs_lang_printer.colorizedBold("ARGUMENT: ", "magenta"),

package/dist/command/error.d.ts

@@ -27,17 +27,25 @@ export interface DataStructureArgumentIssue extends ArgumentIssueBase, DModeling
 export interface CommandArgumentIssueBase {
     readonly path: string;
 }
+export interface UnknownOptionIssue extends CommandArgumentIssueBase, DModeling.ObjectTag<"UnknownOptionIssue"> {
+    readonly optionTokens: readonly string[];
+}
+export interface UnknownSubCommandIssue extends CommandArgumentIssueBase, DModeling.ObjectTag<"UnknownSubCommandIssue"> {
+    readonly subCommandName: string;
+}
 export interface TooMuchCommandArgumentIssue extends CommandArgumentIssueBase, DModeling.ObjectTag<"TooMuchCommandArgumentIssue"> {
     readonly expect: number;
     readonly receive: number;
 }
-export type Issues = (RequiredOptionIssue | RequiredOptionValueIssue | UnexpectedOptionValueIssue | DataStructureOptionIssue | RequiredArgumentIssue | DataStructureArgumentIssue | TooMuchCommandArgumentIssue);
+export type Issues = (RequiredOptionIssue | RequiredOptionValueIssue | UnexpectedOptionValueIssue | DataStructureOptionIssue | RequiredArgumentIssue | DataStructureArgumentIssue | TooMuchCommandArgumentIssue | UnknownOptionIssue | UnknownSubCommandIssue);
 export declare const SymbolCommandError: unique symbol;
 export type SymbolCommandError = typeof SymbolCommandError;
 export interface Error {
     readonly issues: readonly Issues[];
     readonly currentPath: readonly string[];
     pushPath(path: string): void;
+    addUnknownOptionIssue(optionTokens: readonly string[]): SymbolCommandError;
+    addUnknownSubCommandIssue(subCommandName: string): SymbolCommandError;
     addRequiredOptionIssue(optionName: string): SymbolCommandError;
     addRequiredOptionValueIssue(optionName: string): SymbolCommandError;
     addUnexpectedOptionValueIssue(optionName: string, data: unknown): SymbolCommandError;

package/dist/command/error.mjs

@@ -15,6 +15,20 @@ function createError(commandName) {
 		issues,
 		currentPath,
 		pushPath: (path) => void currentPath.push(path),
+		addUnknownOptionIssue: (optionTokens) => {
+			issues.push(DModeling.taggedObject("UnknownOptionIssue", {
+				optionTokens,
+				path: DString.join(currentPath, ".")
+			}));
+			return SymbolCommandError;
+		},
+		addUnknownSubCommandIssue: (subCommandName) => {
+			issues.push(DModeling.taggedObject("UnknownSubCommandIssue", {
+				subCommandName,
+				path: DString.join(currentPath, ".")
+			}));
+			return SymbolCommandError;
+		},
 		addRequiredOptionIssue: (optionName) => {
 			issues.push(DModeling.taggedObject("RequiredOptionIssue", {
 				optionName,
@@ -86,6 +100,16 @@ function interpretDataStructureError(error, dataStructureErrorInterpreter) {
 }
 function interpretErrorIssues(issues, dataStructureErrorInterpreter) {
 	return DPrinter.renderParagraph([DArray.map(issues, DPattern.matchWithTaggedObject({
+		UnknownOptionIssue: ({ optionTokens }) => [DPrinter.render([
+			DPrinter.indent(1),
+			DPrinter.colorizedBold("OPTION: ", "blue"),
+			DString.join(optionTokens, ", ")
+		], ""), `${DPrinter.indent(1)}↳ Unknown Option`],
+		UnknownSubCommandIssue: ({ subCommandName }) => [DPrinter.render([
+			DPrinter.indent(1),
+			DPrinter.colorizedBold("SUB-COMMAND: ", "cyan"),
+			subCommandName
+		], ""), `${DPrinter.indent(1)}↳ Unknown Sub-command`],
 		DataStructureArgumentIssue: ({ argumentName, dataStructureError }) => [DPrinter.render([
 			DPrinter.indent(1),
 			DPrinter.colorizedBold("ARGUMENT: ", "magenta"),

package/dist/command/exec.d.ts

@@ -2,12 +2,13 @@ import { CreateCommandExecuteParams, CreateCommandParams, Subjects } from './cre
 import { Error } from './error';
 import { Option } from './options';
 import { Argument } from './argument';
+import { ForbiddenInvalidIdentifier } from './types';
 import type * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 import type * as DDataStructure from "@duplojs/lang/dataStructure";
-export interface ExecCommandParams<GenericOptions extends DCommon.AnyTuple<Option> = DCommon.AnyTuple<Option>, GenericSubjects extends Subjects = Subjects> extends CreateCommandParams<GenericOptions, GenericSubjects> {
-    displayName?: string;
+export interface ExecCommandParams<GenericOptions extends DCommon.AnyTuple<Option> = DCommon.AnyTuple<Option>, GenericSubjects extends Subjects = Subjects, GenericDisplayName extends string = string> extends CreateCommandParams<GenericOptions, GenericSubjects> {
+    displayName?: GenericDisplayName & ForbiddenInvalidIdentifier<GenericDisplayName>;
     dataStructureErrorInterpreter?: DDataStructure.ErrorInterpreter;
 }
 export declare function exec(execute: () => void): Promise<DEither.Ok | DEither.Error<Error>>;
-export declare function exec<const GenericOptions extends DCommon.AnyTuple<Option> = never, GenericSubjects extends Subjects = never>(params: ExecCommandParams<GenericOptions, GenericSubjects>, execute: (params: CreateCommandExecuteParams<GenericOptions, Extract<GenericSubjects, DCommon.AnyTuple<Argument>>>) => DCommon.MaybePromise<void>): Promise<DEither.Ok | DEither.Error<Error>>;
+export declare function exec<const GenericOptions extends DCommon.AnyTuple<Option> = never, GenericSubjects extends Subjects = never, const GenericDisplayName extends string = string>(params: ExecCommandParams<GenericOptions, GenericSubjects, GenericDisplayName>, execute: (params: CreateCommandExecuteParams<GenericOptions, Extract<GenericSubjects, DCommon.AnyTuple<Argument>>>) => DCommon.MaybePromise<void>): Promise<DEither.Ok | DEither.Error<Error>>;

package/dist/command/help.d.ts

@@ -1,7 +1,7 @@
 import { Command } from './create';
 import { Argument } from './argument';
 import { Options } from './options';
-export declare const helpOption: NoInfer<import('./options').BooleanOption<"help">>;
+export declare const helpOption: import('./options').BooleanOption<"help">;
 export declare function renderOptionsHelp(options: readonly Options[], depth: number): string;
 export declare function renderArgumentsHelp(args: readonly Argument[], depth: number): string;
 export declare function renderCommandHelp(command: Command, depth: number): string[];

package/dist/command/index.cjs

@@ -25,12 +25,14 @@ var command_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	createOption: () => require_simple.createOption,
 	exec: () => require_exec.exec,
 	execOptions: () => require_execOptions.execOptions,
+	findOptionToken: () => require_base.findOptionToken,
 	helpOption: () => require_help.helpOption,
 	interpretDataStructureError: () => require_error.interpretDataStructureError,
 	interpretErrorIssues: () => require_error.interpretErrorIssues,
 	interpretExecCommandError: () => require_error.interpretExecCommandError,
 	interpretExecOptionsError: () => require_error.interpretExecOptionsError,
 	isCommands: () => require_create.isCommands,
+	isOptionToken: () => require_base.isOptionToken,
 	logCommandHelp: () => require_help.logCommandHelp,
 	logExecOptionHelp: () => require_help.logExecOptionHelp,
 	optionIdentifier: () => require_identifier.optionIdentifier,
@@ -61,12 +63,14 @@ exports.createError = require_error.createError;
 exports.createOption = require_simple.createOption;
 exports.exec = require_exec.exec;
 exports.execOptions = require_execOptions.execOptions;
+exports.findOptionToken = require_base.findOptionToken;
 exports.helpOption = require_help.helpOption;
 exports.interpretDataStructureError = require_error.interpretDataStructureError;
 exports.interpretErrorIssues = require_error.interpretErrorIssues;
 exports.interpretExecCommandError = require_error.interpretExecCommandError;
 exports.interpretExecOptionsError = require_error.interpretExecOptionsError;
 exports.isCommands = require_create.isCommands;
+exports.isOptionToken = require_base.isOptionToken;
 exports.logCommandHelp = require_help.logCommandHelp;
 exports.logExecOptionHelp = require_help.logExecOptionHelp;
 exports.optionIdentifier = require_identifier.optionIdentifier;

package/dist/command/index.mjs

@@ -1,7 +1,7 @@
 import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
 import { argumentKind, createArgument } from "./argument.mjs";
 import { SymbolCommandError, createError, interpretDataStructureError, interpretErrorIssues, interpretExecCommandError, interpretExecOptionsError } from "./error.mjs";
-import { constructOption, optionKind } from "./options/base.mjs";
+import { constructOption, findOptionToken, isOptionToken, optionKind } from "./options/base.mjs";
 import { arrayOptionKind, createArrayOption } from "./options/defaults/array.mjs";
 import { booleanOptionKind, createBooleanOption } from "./options/defaults/boolean.mjs";
 import { createOption, simpleOptionKind } from "./options/defaults/simple.mjs";
@@ -25,12 +25,14 @@ var command_exports = /* @__PURE__ */ __exportAll({
 	createOption: () => createOption,
 	exec: () => exec,
 	execOptions: () => execOptions,
+	findOptionToken: () => findOptionToken,
 	helpOption: () => helpOption,
 	interpretDataStructureError: () => interpretDataStructureError,
 	interpretErrorIssues: () => interpretErrorIssues,
 	interpretExecCommandError: () => interpretExecCommandError,
 	interpretExecOptionsError: () => interpretExecOptionsError,
 	isCommands: () => isCommands,
+	isOptionToken: () => isOptionToken,
 	logCommandHelp: () => logCommandHelp,
 	logExecOptionHelp: () => logExecOptionHelp,
 	optionIdentifier: () => optionIdentifier,
@@ -42,4 +44,4 @@ var command_exports = /* @__PURE__ */ __exportAll({
 	simpleOptionKind: () => simpleOptionKind
 });
 //#endregion
-export { SymbolCommandError, argumentKind, arrayOptionKind, booleanOptionKind, command_exports, constructOption, create, createArgument, createArrayOption, createBooleanOption, createError, createOption, exec, execOptions, helpOption, interpretDataStructureError, interpretErrorIssues, interpretExecCommandError, interpretExecOptionsError, isCommands, logCommandHelp, logExecOptionHelp, optionIdentifier, optionKind, renderArgumentsHelp, renderCommandHelp, renderExecOptionHelp, renderOptionsHelp, simpleOptionKind };
+export { SymbolCommandError, argumentKind, arrayOptionKind, booleanOptionKind, command_exports, constructOption, create, createArgument, createArrayOption, createBooleanOption, createError, createOption, exec, execOptions, findOptionToken, helpOption, interpretDataStructureError, interpretErrorIssues, interpretExecCommandError, interpretExecOptionsError, isCommands, isOptionToken, logCommandHelp, logExecOptionHelp, optionIdentifier, optionKind, renderArgumentsHelp, renderCommandHelp, renderExecOptionHelp, renderOptionsHelp, simpleOptionKind };

package/dist/command/options/base.cjs

@@ -9,24 +9,30 @@ let _duplojs_lang_string = require("@duplojs/lang/string");
 _duplojs_lang_string = require_runtime.__toESM(_duplojs_lang_string, 1);
 //#region scripts/command/options/base.ts
 const optionKind = require_kind.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 _duplojs_lang_string.test(input, regexOption);
+}
+function findOptionToken(args, option) {
+	return _duplojs_lang_array.reduce(args, _duplojs_lang_array.reduceFrom(null), ({ element, next, exit, index }) => {
+		const extractResult = _duplojs_lang_string.extract(element, regexOption);
+		if (!extractResult) return next(null);
+		const key = extractResult.namedGroups.key;
+		if (option.name !== key && (!_duplojs_lang_array.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 = _duplojs_lang_array.reduce(args, _duplojs_lang_array.reduceFrom(null), ({ element, next, exit, index }) => {
-					const extractResult = _duplojs_lang_string.extract(element, regexOption);
-					if (!extractResult) return next(null);
-					const result = {
-						key: extractResult.namedGroups.key,
-						value: extractResult.namedGroups?.value,
-						index
-					};
-					if (self.name !== result.key && (!_duplojs_lang_array.includes(self.aliases, result.key) || extractResult.namedGroups?.dashes !== "-")) return next(null);
-					return exit(result);
-				});
+				const result = findOptionToken(args, self);
 				const { value, argumentRest } = _duplojs_lang_common.justExec(() => {
 					if (!result) return {
 						value: null,
@@ -34,7 +40,7 @@ function constructOption(kindHandler, createConstructor) {
 					};
 					if (result.value === void 0) {
 						const nextArg = args[result.index + 1];
-						if (nextArg === void 0 || _duplojs_lang_string.test(nextArg, regexOption)) return {
+						if (nextArg === void 0 || isOptionToken(nextArg)) return {
 							value: void 0,
 							argumentRest: _duplojs_lang_array.spliceDelete(args, result.index, 1)
 						};
@@ -65,4 +71,6 @@ function constructOption(kindHandler, createConstructor) {
 }
 //#endregion
 exports.constructOption = constructOption;
+exports.findOptionToken = findOptionToken;
+exports.isOptionToken = isOptionToken;
 exports.optionKind = optionKind;

package/dist/command/options/base.d.ts

@@ -2,6 +2,12 @@ import { Error, SymbolCommandError } from '../error';
 import * as DCommon from "@duplojs/lang/common";
 import type * as DKind from "@duplojs/lang/kind";
 export declare const optionKind: DKind.Handler<DKind.Definition<"@DuplojsServerCommand/command-option", unknown>>;
+export declare function isOptionToken(input: string): boolean;
+export declare function findOptionToken(args: readonly string[], option: Pick<Option, "name" | "aliases">): {
+    key: string;
+    value: string | undefined;
+    index: number;
+} | null;
 export interface Option<GenericName extends string = string, GenericValue extends unknown = unknown> extends DKind.Kind<typeof optionKind> {
     readonly name: GenericName;
     readonly description: string | null;

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

@@ -2,4 +2,4 @@ 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-error", DSFile.ReadTextFileErrors> | 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/dataStructure/helper/file.d.ts

@@ -1,3 +1,3 @@
 import * as DDataStructure from "@duplojs/lang/dataStructure";
 import type * as DSFile from '../../file';
-export declare function file<const GenericConstraints extends readonly DDataStructure.Constraint<DSFile.FileInterface>[] = readonly []>(constraints?: GenericConstraints): NoInfer<DDataStructure.TypeStructure<DSFile.FileInterface<DSFile.EntryPath>, readonly [...GenericConstraints]>>;
+export declare function file<const GenericConstraints extends readonly DDataStructure.Constraint<DSFile.FileInterface>[] = readonly []>(constraints?: GenericConstraints): NoInfer<DDataStructure.TypeStructure<DSFile.FileInterface<import('@duplojs/lang/path').AnyPath>, readonly [...GenericConstraints]>>;

package/dist/dataStructure/helper/folder.d.ts

@@ -1,3 +1,3 @@
 import * as DDataStructure from "@duplojs/lang/dataStructure";
 import type * as DSFile from '../../file';
-export declare function folder<const GenericConstraints extends readonly DDataStructure.Constraint<DSFile.FolderInterface>[] = readonly []>(constraints?: GenericConstraints): NoInfer<DDataStructure.TypeStructure<DSFile.FolderInterface<DSFile.EntryPath>, readonly [...GenericConstraints]>>;
+export declare function folder<const GenericConstraints extends readonly DDataStructure.Constraint<DSFile.FolderInterface>[] = readonly []>(constraints?: GenericConstraints): NoInfer<DDataStructure.TypeStructure<DSFile.FolderInterface<import('@duplojs/lang/path').AnyPath>, readonly [...GenericConstraints]>>;