alepha 0.13.8 → 0.14.1

package/dist/core/index.native.js

@@ -418,1483 +418,1556 @@ var TypeBoxError = class extends AlephaError {
 };
 
 //#endregion
-//#region ../../src/core/providers/SchemaValidator.ts
-var SchemaValidator = class {
-	cache = /* @__PURE__ */ new Map();
-	/**
-	* Validate the value against the provided schema.
-	*
-	* Validation create a new value by applying some preprocessing. (e.g., trimming text)
-	*/
-	validate(schema, value, options = {}) {
-		const newValue = this.beforeParse(schema, value, {
-			trim: options.trim ?? true,
-			nullToUndefined: options.nullToUndefined ?? true,
-			deleteUndefined: options.deleteUndefined ?? true
+//#region ../../src/core/primitives/$hook.ts
+/**
+* Registers a new hook.
+*
+* ```ts
+* import { $hook } from "alepha";
+*
+* class MyProvider {
+*   onStart = $hook({
+*     name: "start", // or "configure", "ready", "stop", ...
+*     handler: async (app) => {
+*       // await db.connect(); ...
+*     }
+*   });
+* }
+* ```
+*
+* Hooks are used to run async functions from all registered providers/services.
+*
+* You can't register a hook after the App has started.
+*
+* It's used under the hood by the `configure`, `start`, and `stop` methods.
+* Some modules also use hooks to run their own logic. (e.g. `alepha/server`).
+*
+* You can create your own hooks by using module augmentation:
+*
+* ```ts
+* declare module "alepha" {
+*
+*   interface Hooks {
+*     "my:custom:hook": {
+*       arg1: string;
+*     }
+*   }
+* }
+*
+* await alepha.events.emit("my:custom:hook", { arg1: "value" });
+* ```
+*
+*/
+const $hook = (options) => createPrimitive(HookPrimitive, options);
+var HookPrimitive = class extends Primitive {
+	called = 0;
+	onInit() {
+		this.alepha.events.on(this.options.on, {
+			caller: this.config.service,
+			priority: this.options.priority,
+			callback: async (args) => {
+				this.called += 1;
+				await this.options.handler(args);
+			}
 		});
-		try {
-			return this.getValidator(schema).Parse(newValue);
-		} catch (error) {
-			if (error.cause?.errors?.[0]) throw new TypeBoxError(error.cause.errors[0]);
-			throw error;
-		}
 	}
-	getValidator(schema) {
-		if (this.cache.has(schema)) return this.cache.get(schema);
-		const validator = Compile(schema);
-		this.cache.set(schema, validator);
-		return validator;
+};
+$hook[KIND] = HookPrimitive;
+
+//#endregion
+//#region ../../src/core/helpers/FileLike.ts
+const isTypeFile = (value) => {
+	return value && typeof value === "object" && "format" in value && value.format === "binary";
+};
+const isFileLike = (value) => {
+	return !!value && typeof value === "object" && !Array.isArray(value) && typeof value.name === "string" && typeof value.type === "string" && typeof value.size === "number" && typeof value.stream.bind(value) === "function";
+};
+
+//#endregion
+//#region ../../src/core/providers/TypeProvider.ts
+const isUUID = Format.IsUuid;
+var TypeGuard = class {
+	isBigInt = (value) => Type.IsString(value) && "format" in value && value.format === "bigint";
+	isUUID = (value) => Type.IsString(value) && "format" in value && value.format === "uuid";
+	isObject = Type.IsObject;
+	isNumber = Type.IsNumber;
+	isString = Type.IsString;
+	isBoolean = Type.IsBoolean;
+	isAny = Type.IsAny;
+	isArray = Type.IsArray;
+	isOptional = Type.IsOptional;
+	isUnion = Type.IsUnion;
+	isInteger = Type.IsInteger;
+	isNull = Type.IsNull;
+	isUndefined = Type.IsUndefined;
+	isUnsafe = Type.IsUnsafe;
+	isRecord = Type.IsRecord;
+	isTuple = Type.IsTuple;
+	isVoid = Type.IsVoid;
+	isLiteral = Type.IsLiteral;
+	isSchema = Type.IsSchema;
+	isFile = isTypeFile;
+	isDateTime = (schema) => {
+		return t.schema.isString(schema) && schema.format === "date-time";
+	};
+	isDate = (schema) => {
+		return t.schema.isString(schema) && schema.format === "date";
+	};
+	isTime = (schema) => {
+		return t.schema.isString(schema) && schema.format === "time";
+	};
+	isDuration = (schema) => {
+		return t.schema.isString(schema) && schema.format === "duration";
+	};
+};
+var TypeProvider = class TypeProvider {
+	static format = Format;
+	static {
+		Format.Set("bigint", (value) => TypeProvider.isValidBigInt(value));
 	}
-	/**
-	* Preprocess the value based on the schema before validation.
-	*
-	* - If the value is `null` and the schema does not allow `null`, it converts it to `undefined`.
-	* - If the value is a string and the schema has a `~options.trim` flag, it trims whitespace from the string.
-	*/
-	beforeParse(schema, value, options) {
-		if (!schema) return value;
-		if (value === null && !this.isSchemaNullable(schema) && options.nullToUndefined) return;
-		if (Array.isArray(value)) return value.map((it) => this.beforeParse(schema.items, it, options));
-		if (typeof value === "string" && schema.type === "string") {
-			let str = value;
-			if (options.trim && schema["~options"]?.trim) str = str.trim();
-			if (schema["~options"]?.lowercase) str = str.toLowerCase();
-			return str;
+	static translateError(error, locale) {
+		if (!locale) return error.cause.message;
+		for (const [key, value] of Object.entries(Locale)) {
+			if (key === "Set" || key === "Get" || key === "Reset") continue;
+			if (key === locale || key.startsWith(`${locale}_`)) return value(error.cause);
 		}
-		if (typeof value === "object" && value !== null && schema.type === "object") {
-			const obj = {};
-			for (const key in value) {
-				const newValue = this.beforeParse(schema.properties?.[key], value[key], options);
-				if (newValue === void 0 && options.deleteUndefined) continue;
-				obj[key] = newValue;
+		return error.cause.message;
+	}
+	static setLocale(locale) {
+		for (const [key, value] of Object.entries(Locale)) {
+			if (key === "Set" || key === "Get" || key === "Reset") continue;
+			if (key === locale || key.startsWith(`${locale}_`)) {
+				Locale.Set(value);
+				return;
 			}
-			return obj;
 		}
-		return value;
+		throw new AlephaError(`Locale not found: ${locale}`);
 	}
-	/**
-	* Used by `beforeParse` to determine if a schema allows null values.
-	*/
-	isSchemaNullable = (schema) => {
-		if (!schema) return false;
-		if (schema.type === "null") return true;
-		if (Array.isArray(schema.type) && schema.type.includes("null")) return true;
-		if (schema.anyOf) return schema.anyOf.some((it) => this.isSchemaNullable(it));
-		if (schema.oneOf) return schema.oneOf.some((it) => this.isSchemaNullable(it));
-		if (schema.allOf) return schema.allOf.some((it) => this.isSchemaNullable(it));
-		return false;
-	};
-};
-
-//#endregion
-//#region ../../src/core/providers/CodecManager.ts
-/**
-* CodecManager manages multiple codec formats and provides a unified interface
-* for encoding and decoding data with different formats.
-*/
-var CodecManager = class {
-	codecs = /* @__PURE__ */ new Map();
-	jsonCodec = $inject(JsonSchemaCodec);
-	schemaValidator = $inject(SchemaValidator);
-	default = "json";
-	constructor() {
-		this.register(this.default, this.jsonCodec);
+	static isValidBigInt(value) {
+		if (typeof value === "number") return Number.isInteger(value);
+		if (!value.trim()) return false;
+		if (!/^-?\d+$/.test(value)) return false;
+		try {
+			BigInt(value);
+			return true;
+		} catch {
+			return false;
+		}
 	}
 	/**
-	* Register a new codec format.
+	* Default maximum length for strings.
 	*
-	* @param name - The name of the codec (e.g., 'json', 'protobuf')
-	* @param codec - The codec implementation
+	* It can be set to a larger value:
+	* ```ts
+	* TypeProvider.DEFAULT_STRING_MAX_LENGTH = 1000000;
+	* TypeProvider.DEFAULT_STRING_MAX_LENGTH = undefined; // no limit (not recommended)
+	* ```
 	*/
-	register(name, codec) {
-		this.codecs.set(name, codec);
-	}
+	static DEFAULT_STRING_MAX_LENGTH = 255;
 	/**
-	* Get a specific codec by name.
-	*
-	* @param name - The name of the codec
-	* @returns The codec instance
-	* @throws {AlephaError} If the codec is not found
+	* Maximum length for short strings, such as names or titles.
 	*/
-	getCodec(name) {
-		const codec = this.codecs.get(name);
-		if (!codec) throw new AlephaError(`Codec "${name}" not found. Available codecs: ${Array.from(this.codecs.keys()).join(", ")}`);
-		return codec;
-	}
+	static DEFAULT_SHORT_STRING_MAX_LENGTH = 64;
 	/**
-	* Encode data using the specified codec and output format.
+	* Maximum length for long strings, such as descriptions or comments.
+	* It can be overridden in the string options.
+	*
+	* It can be set to a larger value:
+	* ```ts
+	* TypeProvider.DEFAULT_LONG_STRING_MAX_LENGTH = 2048;
+	* ```
 	*/
-	encode(schema, value, options) {
-		const codec = this.getCodec(options?.encoder ?? this.default);
-		const as = options?.as ?? "object";
-		if (options?.validation !== false) value = this.schemaValidator.validate(schema, value, options?.validation);
-		if (as === "object") return value;
-		if (as === "binary") return codec.encodeToBinary(schema, value);
-		return codec.encodeToString(schema, value);
-	}
+	static DEFAULT_LONG_STRING_MAX_LENGTH = 1024;
 	/**
-	* Decode data using the specified codec.
+	* Maximum length for rich strings, such as HTML or Markdown.
+	* This is a large value to accommodate rich text content.
+	* > It's also the maximum length of PG's TEXT type.
+	*
+	* It can be overridden in the string options.
+	*
+	* It can be set to a larger value:
+	* ```ts
+	* TypeProvider.DEFAULT_RICH_STRING_MAX_LENGTH = 1000000;
+	* ```
 	*/
-	decode(schema, data, options) {
-		const encoderName = options?.encoder ?? this.default;
-		let value = this.getCodec(encoderName).decode(schema, data);
-		if (options?.validation !== false) value = this.schemaValidator.validate(schema, value, options?.validation);
-		return value;
+	static DEFAULT_RICH_STRING_MAX_LENGTH = 65535;
+	/**
+	* Maximum number of items in an array.
+	* This is a default value to prevent excessive memory usage.
+	* It can be overridden in the array options.
+	*/
+	static DEFAULT_ARRAY_MAX_ITEMS = 1e3;
+	raw = Type;
+	any = Type.Any;
+	void = Type.Void;
+	undefined = Type.Undefined;
+	record = Type.Record;
+	union = Type.Union;
+	tuple = Type.Tuple;
+	null = Type.Null;
+	const = Type.Literal;
+	options = Type.Options;
+	/**
+	* Type guards to check the type of schema.
+	* This is not a runtime type check, but a compile-time type guard.
+	*
+	* @example
+	* ```ts
+	* if (t.schema.isString(schema)) {
+	*   // schema is TString
+	* }
+	* ```
+	*/
+	schema = new TypeGuard();
+	extend(schema, properties, options) {
+		return Type.Interface(Array.isArray(schema) ? schema : [schema], properties, {
+			additionalProperties: false,
+			...options
+		});
+	}
+	pick(schema, keys, options) {
+		return Type.Pick(schema, keys, {
+			additionalProperties: false,
+			...options
+		});
+	}
+	omit(schema, keys, options) {
+		return Type.Omit(schema, keys, {
+			additionalProperties: false,
+			...options
+		});
+	}
+	partial(schema, options) {
+		return Type.Partial(schema, {
+			additionalProperties: false,
+			...options
+		});
 	}
 	/**
-	* Validate decoded data against the schema.
+	* Create a schema for an object.
+	* By default, additional properties are not allowed.
 	*
-	* This is automatically called before encoding or after decoding.
+	* @example
+	* ```ts
+	* const userSchema = t.object({
+	*   id: t.integer(),
+	*   name: t.string(),
+	* });
+	* ```
 	*/
-	validate(schema, value, options) {
-		return this.schemaValidator.validate(schema, value, options);
+	object(properties, options) {
+		return Type.Object(properties, {
+			additionalProperties: false,
+			...options
+		});
 	}
-};
-
-//#endregion
-//#region ../../src/core/providers/EventManager.ts
-var EventManager = class {
-	logFn;
 	/**
-	* List of events that can be triggered. Powered by $hook().
+	* Create a schema for an array.
+	* By default, the maximum number of items is limited to prevent excessive memory usage.
+	*
+	* @see TypeProvider.DEFAULT_ARRAY_MAX_ITEMS
 	*/
-	events = {};
-	constructor(logFn) {
-		this.logFn = logFn;
+	array(schema, options) {
+		return Type.Array(schema, {
+			maxItems: TypeProvider.DEFAULT_ARRAY_MAX_ITEMS,
+			...options
+		});
 	}
-	get log() {
-		return this.logFn?.();
+	/**
+	* Create a schema for a string.
+	* For db or input fields, consider using `t.text()` instead, which has length limits.
+	*
+	* If you need a string with specific format (e.g. email, uuid), consider using the corresponding method (e.g. `t.email()`, `t.uuid()`).
+	*/
+	string(options = {}) {
+		return Type.String({ ...options });
 	}
 	/**
-	* Registers a hook for the specified event.
+	* Create a schema for a string with length limits.
+	* For internal strings without length limits, consider using `t.string()` instead.
+	*
+	* Default size is "regular", which has a max length of 255 characters.
 	*/
-	on(event, hookOrFunc) {
-		if (!this.events[event]) this.events[event] = [];
-		const hook = typeof hookOrFunc === "function" ? { callback: hookOrFunc } : hookOrFunc;
-		if (hook.priority === "first") this.events[event].unshift(hook);
-		else if (hook.priority === "last") this.events[event].push(hook);
-		else {
-			const index = this.events[event].findIndex((it) => it.priority === "last");
-			if (index !== -1) this.events[event].splice(index, 0, hook);
-			else this.events[event].push(hook);
-		}
-		return () => {
-			this.events[event] = this.events[event].filter((it) => it.callback !== hook.callback);
-		};
+	text(options = {}) {
+		const { size, ...rest } = options;
+		const maxLength = size === "short" ? TypeProvider.DEFAULT_SHORT_STRING_MAX_LENGTH : size === "long" ? TypeProvider.DEFAULT_LONG_STRING_MAX_LENGTH : size === "rich" ? TypeProvider.DEFAULT_RICH_STRING_MAX_LENGTH : TypeProvider.DEFAULT_STRING_MAX_LENGTH;
+		return Type.String({
+			maxLength,
+			"~options": {
+				trim: options.trim ?? true,
+				lowercase: options.lowercase ?? false
+			},
+			...rest
+		});
 	}
 	/**
-	* Emits the specified event with the given payload.
+	* Create a schema for a JSON object.
+	* This is a record with string keys and any values.
 	*/
-	async emit(func, payload, options = {}) {
-		const ctx = {};
-		if (options.log) {
-			ctx.now = Date.now();
-			this.log?.trace(`${func} ...`);
-		}
-		let events = this.events[func] ?? [];
-		if (options.reverse) events = events.toReversed();
-		for (const hook of events) {
-			const name = hook.caller?.name ?? "unknown";
-			if (options.log) {
-				ctx.now2 = Date.now();
-				this.log?.trace(`${func}(${name}) ...`);
-			}
-			try {
-				await hook.callback(payload);
-			} catch (error) {
-				if (options.catch) {
-					this.log?.error(`${func}(${name}) ERROR`, error);
-					continue;
-				}
-				if (options.log) throw new AlephaError(`Failed during '${func}()' hook for service: ${name}`, { cause: error });
-				throw error;
-			}
-			if (options.log) this.log?.debug(`${func}(${name}) OK [${Date.now() - ctx.now2}ms]`);
-		}
-		if (options.log) this.log?.debug(`${func} OK [${Date.now() - ctx.now}ms]`);
+	json(options) {
+		return t.record(t.text(), t.any(), options);
 	}
-};
-
-//#endregion
-//#region ../../src/core/primitives/$atom.ts
-/**
-* Define an atom for state management.
-*
-* Atom lets you define a piece of state with a name, schema, and default value.
-*
-* By default, Alepha state is just a simple key-value store.
-* Using atoms allows you to have type safety, validation, and default values for your state.
-*
-* You control how state is structured and validated.
-*
-* Features:
-* - Set a schema for validation
-* - Set a default value for initial state
-* - Rules, like read-only, custom validation, etc.
-* - Automatic getter access in services with {@link $use}
-* - SSR support (server state automatically serialized and hydrated on client)
-* - React integration (useAtom hook for automatic component re-renders)
-* - Middleware
-* - Persistence adapters (localStorage, Redis, database, file system, cookie, etc.)
-* - State migrations (version upgrades when schema changes)
-* - Documentation generation & devtools integration
-*
-* Common use cases:
-* - user preferences
-* - feature flags
-* - configuration options
-* - session data
-*
-* Atom must contain only serializable data.
-* Avoid storing complex objects like class instances, functions, or DOM elements.
-* If you need to store complex data, consider using identifiers or references instead.
-*/
-const $atom = (options) => {
-	return new Atom(options);
-};
-var Atom = class {
-	options;
-	get schema() {
-		return this.options.schema;
+	/**
+	* Create a schema for a boolean.
+	*/
+	boolean(options) {
+		return Type.Boolean({ ...options });
 	}
-	get key() {
-		return this.options.name;
+	/**
+	* Create a schema for a number.
+	*/
+	number(options) {
+		return Type.Number({ ...options });
 	}
-	constructor(options) {
-		this.options = options;
+	/**
+	* Create a schema for an integer.
+	*/
+	integer(options) {
+		return Type.Integer({ ...options });
 	}
-};
-$atom[KIND] = "atom";
-
-//#endregion
-//#region ../../src/core/providers/StateManager.ts
-var StateManager = class {
-	als = $inject(AlsProvider);
-	events = $inject(EventManager);
-	codec = $inject(JsonSchemaCodec);
-	atoms = /* @__PURE__ */ new Map();
-	store = {};
-	constructor(store = {}) {
-		this.store = store;
+	int32(options) {
+		return Type.Integer({
+			minimum: -2147483647,
+			maximum: 2147483647,
+			...options
+		});
 	}
-	getAtoms(context = true) {
-		const atoms = [];
-		if (context && this.als?.exists()) for (const atom of this.atoms.values()) {
-			const value = this.als.get(atom.key);
-			if (value !== void 0) atoms.push({
-				atom,
-				value
-			});
-		}
-		else for (const [key, atom] of this.atoms.entries()) atoms.push({
-			atom,
-			value: this.store[key]
+	/**
+	* Mimic a signed 64-bit integer.
+	*
+	* This is NOT a true int64, as JavaScript cannot represent all int64 values.
+	* It is a number that is an integer and between -9007199254740991 and 9007199254740991.
+	* Use `t.bigint()` for true int64 values represented as strings.
+	*/
+	int64(options) {
+		return Type.Number({
+			format: "int64",
+			multipleOf: 1,
+			minimum: -9007199254740991,
+			maximum: 9007199254740991,
+			...options
 		});
-		return atoms;
 	}
-	register(atom) {
-		const key = atom.key;
-		if (!this.atoms.has(key)) {
-			this.atoms.set(key, atom);
-			if (!(key in this.store)) this.set(key, atom.options.default, { skipContext: true });
-		}
-		return this;
+	/**
+	* Make a schema optional.
+	*/
+	optional(schema) {
+		return Type.Optional(schema);
 	}
-	get(target) {
-		if (target instanceof Atom) this.register(target);
-		const key = target instanceof Atom ? target.key : target;
-		const store = this.store;
-		return this.als?.exists() ? this.als.get(key) ?? store[key] : store[key];
+	/**
+	* Make a schema nullable.
+	*/
+	nullable(schema, options) {
+		return Type.Union([Type.Null(), schema], options);
 	}
-	set(target, value, options) {
-		if (target instanceof Atom) this.register(target);
-		const key = target instanceof Atom ? target.key : target;
-		const store = this.store;
-		const prevValue = this.get(key);
-		if (prevValue === value) return this;
-		if (options?.skipContext !== true && this.als?.exists()) this.als.set(key, value);
-		else store[key] = value;
-		if (options?.skipEvents !== true) this.events?.emit("state:mutate", {
-			key,
-			value,
-			prevValue
-		}, { catch: true }).catch(() => null);
-		return this;
+	/**
+	* Create a schema that maps all properties of an object schema to nullable.
+	*/
+	nullify = (schema, options) => Type.Mapped(Type.Identifier("K"), Type.KeyOf(schema), Type.Ref("K"), Type.Union([Type.Index(schema, Type.Ref("K")), Type.Null()]), options);
+	/**
+	* Create a schema for a string enum.
+	*/
+	enum(values, options) {
+		return Type.Unsafe(t.text({
+			enum: values,
+			pattern: values.map((v) => `^${v}$`).join("|"),
+			...options
+		}));
 	}
-	mut(target, mutator) {
-		const updated = mutator(this.get(target));
-		return this.set(target, updated);
+	/**
+	* Create a schema for a bigint represented as a string.
+	* This is a string that validates bigint format (e.g. "123456789").
+	*/
+	bigint(options) {
+		return t.string({
+			...options,
+			format: "bigint"
+		});
 	}
 	/**
-	* Check if a key exists in the state
+	* Create a schema for a URL represented as a string.
 	*/
-	has(key) {
-		return key in this.store;
+	url(options) {
+		return this.string({
+			...options,
+			format: "url"
+		});
 	}
 	/**
-	* Delete a key from the state (set to undefined)
+	* Create a schema for binary data represented as a base64 string.
 	*/
-	del(key) {
-		return this.set(key, void 0);
+	binary(options) {
+		return this.string({
+			...options,
+			format: "binary"
+		});
 	}
 	/**
-	* Push a value to an array in the state
+	* Create a schema for uuid.
 	*/
-	push(key, ...value) {
-		const current = this.get(key) ?? [];
-		if (Array.isArray(current)) this.set(key, [...current, ...value]);
-		return this;
+	uuid(options) {
+		return this.string({
+			...options,
+			format: "uuid"
+		});
 	}
 	/**
-	* Clear all state
+	* Create a schema for a file-like object.
+	*
+	* File like mimics the File API in browsers, but is adapted to work in Node.js as well.
+	*
+	* Implementation of file-like objects is handled by "alepha/file" package.
 	*/
-	clear() {
-		this.store = {};
-		return this;
+	file(options) {
+		return Type.Unsafe(Type.Any({
+			[OPTIONS]: options,
+			format: "binary"
+		}));
 	}
 	/**
-	* Get all keys that exist in the state
+	* @experimental
 	*/
-	keys() {
-		return Object.keys(this.store);
+	stream() {
+		return Type.Unsafe(Type.Any({
+			format: "stream",
+			type: "string"
+		}));
+	}
+	email(options) {
+		return this.text({
+			...options,
+			format: "email",
+			trim: true,
+			lowercase: true
+		});
+	}
+	e164(options) {
+		return this.text({
+			...options,
+			description: "Phone number in E.164 format, e.g. +1234567890.",
+			pattern: "^\\+[1-9]\\d{1,14}$"
+		});
+	}
+	bcp47(options) {
+		return this.text({
+			...options,
+			description: "BCP 47 language tag, e.g. en, en-US, fr, fr-CA.",
+			pattern: "^[a-z]{2,3}(?:-[A-Z]{2})?$"
+		});
+	}
+	/**
+	* Create a schema for short text, such as names or titles.
+	* Default max length is 64 characters.
+	*/
+	shortText(options) {
+		return this.text({
+			size: "short",
+			...options
+		});
+	}
+	/**
+	* Create a schema for long text, such as descriptions or comments.
+	* Default max length is 1024 characters.
+	*/
+	longText(options) {
+		return this.text({
+			size: "long",
+			...options
+		});
+	}
+	/**
+	* Create a schema for rich text, such as HTML or Markdown.
+	* Default max length is 65535 characters.
+	*/
+	richText(options) {
+		return this.text({
+			size: "rich",
+			...options
+		});
 	}
+	/**
+	* Create a schema for a string enum e.g. LIKE_THIS.
+	*/
+	snakeCase = (options) => this.text({
+		pattern: "^[A-Z_-]+$",
+		...options
+	});
+	/**
+	* Create a schema for an object with a value and label.
+	*/
+	valueLabel = (options) => this.object({
+		value: this.snakeCase({ description: "Machine-readable value." }),
+		label: this.text({ description: "Human-readable label." }),
+		description: this.optional(this.text({
+			description: "Description of the value.",
+			size: "long"
+		}))
+	}, options);
+	datetime = (options) => t.text({
+		...options,
+		format: "date-time"
+	});
+	date = (options) => t.text({
+		...options,
+		format: "date"
+	});
+	time = (options) => t.text({
+		...options,
+		format: "time"
+	});
+	duration = (options) => t.text({
+		...options,
+		format: "duration"
+	});
 };
+const t = new TypeProvider();
 
 //#endregion
-//#region ../../src/core/Alepha.ts
-/**
-* Core container of the Alepha framework.
-*
-* It is responsible for managing the lifecycle of services,
-* handling dependency injection,
-* and providing a unified interface for the application.
-*
-* @example
-* ```ts
-* import { Alepha, run } from "alepha";
-*
-* class MyService {
-*   // business logic here
-* }
-*
-* const alepha = Alepha.create({
-*   // state, env, and other properties
-* })
-*
-* alepha.with(MyService);
-*
-* run(alepha); // trigger .start (and .stop) automatically
-* ```
-*
-* ### Alepha Factory
-*
-* Alepha.create() is an enhanced version of new Alepha().
-* - It merges `process.env` with the provided state.env when available.
-* - It populates the test hooks for Vitest or Jest environments when available.
-*
-* new Alepha() is fine if you don't need these helpers.
-*
-* ### Platforms & Environments
-*
-* Alepha is designed to work in various environments:
-* - **Browser**: Runs in the browser, using the global `window` object.
-* - **Serverless**: Runs in serverless environments like Vercel or Vite.
-* - **Test**: Runs in test environments like Jest or Vitest.
-* - **Production**: Runs in production environments, typically with NODE_ENV set to "production".
-* * You can check the current environment using the following methods:
-*
-* - `isBrowser()`: Returns true if the App is running in a browser environment.
-* - `isServerless()`: Returns true if the App is running in a serverless environment.
-* - `isTest()`: Returns true if the App is running in a test environment.
-* - `isProduction()`: Returns true if the App is running in a production environment.
-*
-* ### State & Environment
-*
-* The state of the Alepha container is stored in the `store` property.
-* Most important property is `store.env`, which contains the environment variables.
-*
-* ```ts
-* const alepha = Alepha.create({ env: { MY_VAR: "value" } });
-*
-* // You can access the environment variables using alepha.env
-* console.log(alepha.env.MY_VAR); // "value"
-*
-* // But you should use $env() primitive to get typed values from the environment.
-* class App {
-*   env = $env(
-*     t.object({
-*  	   MY_VAR: t.text(),
-*     })
-*   );
-* }
-* ```
-*
-* ### Modules
-*
-* Modules are a way to group services together.
-* You can register a module using the `$module` primitive.
-*
-* ```ts
-* import { $module } from "alepha";
-*
-* class MyLib {}
-*
-* const myModule = $module({
-*   name: "my.project.module",
-*   services: [MyLib],
-* });
-* ```
-*
-* Do not use modules for small applications.
-*
-* ### Hooks
-*
-* Hooks are a way to run async functions from all registered providers/services.
-* You can register a hook using the `$hook` primitive.
-*
-* ```ts
-* import { $hook } from "alepha";
-*
-* class App {
-* 	 log = $logger();
-* 	 onCustomerHook = $hook({
-* 			on: "my:custom:hook",
-* 			handler: () => {
-* 		 	  this.log?.info("App is being configured");
-* 	 		},
-* 	  });
-* 	}
-*
-* Alepha.create()
-* 	 .with(App)
-* 	 .start()
-* 	 .then(alepha => alepha.events.emit("my:custom:hook"));
-* ```
-*
-* 	Hooks are fully typed. You can create your own hooks by using module augmentation:
-*
-* 	```ts
-* 	declare module "alepha" {
-* 		interface Hooks {
-* 		  "my:custom:hook": {
-* 				arg1: string;
-* 		  }
-* 		}
-* 	}
-* 	```
-*
-* 	@module alepha
-*/
-var Alepha = class Alepha {
+//#region ../../src/core/providers/SchemaValidator.ts
+var SchemaValidator = class {
+	cache = /* @__PURE__ */ new Map();
+	useEval = true;
 	/**
-	* Creates a new instance of the Alepha container with some helpers:
+	* Validate the value against the provided schema.
 	*
-	* - merges `process.env` with the provided state.env when available.
-	* - populates the test hooks for Vitest or Jest environments when available.
+	* Validation create a new value by applying some preprocessing. (e.g., trimming text)
+	*/
+	validate(schema, value, options = {}) {
+		const newValue = this.beforeParse(schema, value, {
+			trim: options.trim ?? true,
+			nullToUndefined: options.nullToUndefined ?? true,
+			deleteUndefined: options.deleteUndefined ?? true
+		});
+		try {
+			if (!this.useEval) return Value.Parse(schema, newValue);
+			return this.getValidator(schema).Parse(newValue);
+		} catch (error) {
+			if (error.cause?.errors?.[0]) throw new TypeBoxError(error.cause.errors[0]);
+			throw error;
+		}
+	}
+	getValidator(schema) {
+		if (this.cache.has(schema)) return this.cache.get(schema);
+		const validator = Compile(schema);
+		this.cache.set(schema, validator);
+		return validator;
+	}
+	/**
+	* Preprocess the value based on the schema before validation.
 	*
-	* If you are not interested about these helpers, you can use the constructor directly.
+	* - If the value is `null` and the schema does not allow `null`, it converts it to `undefined`.
+	* - If the value is a string and the schema has a `~options.trim` flag, it trims whitespace from the string.
 	*/
-	static create(state = {}) {
-		if (typeof process === "object" && typeof process.env === "object") {
-			state.env = {
-				...state.env,
-				...process.env
-			};
-			if (process.env.NODE_ENV === "production") state.env.NODE_ENV ??= "production";
+	beforeParse(schema, value, options) {
+		if (!schema) return value;
+		if (value === null && !this.isSchemaNullable(schema) && options.nullToUndefined) return;
+		if (Array.isArray(value)) return value.map((it) => this.beforeParse(schema.items, it, options));
+		if (typeof value === "string" && schema.type === "string") {
+			let str = value;
+			if (options.trim && schema["~options"]?.trim) str = str.trim();
+			if (schema["~options"]?.lowercase) str = str.toLowerCase();
+			return str;
 		}
-		const alepha = new Alepha(state);
-		if (alepha.isTest()) {
-			const g = globalThis;
-			const beforeAll = state["alepha.test.beforeAll"] ?? g.beforeAll;
-			const afterAll = state["alepha.test.afterAll"] ?? g.afterAll;
-			const afterEach = state["alepha.test.afterEach"] ?? g.afterEach;
-			const onTestFinished = state["alepha.test.onTestFinished"] ?? g.onTestFinished;
-			beforeAll?.(() => alepha.start());
-			afterAll?.(() => alepha.stop());
-			try {
-				onTestFinished?.(() => alepha.stop());
-			} catch (_error) {}
-			alepha.store.set("alepha.test.beforeAll", beforeAll).set("alepha.test.afterAll", afterAll).set("alepha.test.afterEach", afterEach).set("alepha.test.onTestFinished", onTestFinished);
+		if (typeof value === "object" && value !== null && schema.type === "object") {
+			const obj = {};
+			for (const key in value) {
+				const newValue = this.beforeParse(schema.properties?.[key], value[key], options);
+				if (newValue === void 0 && options.deleteUndefined) continue;
+				obj[key] = newValue;
+			}
+			return obj;
 		}
-		return alepha;
+		return value;
 	}
 	/**
-	* Flag indicating whether the App won't accept any further changes.
-	* Pass to true when #start() is called.
+	* Used by `beforeParse` to determine if a schema allows null values.
 	*/
-	locked = false;
+	isSchemaNullable = (schema) => {
+		if (!schema) return false;
+		if (schema.type === "null") return true;
+		if (Array.isArray(schema.type) && schema.type.includes("null")) return true;
+		if (schema.anyOf) return schema.anyOf.some((it) => this.isSchemaNullable(it));
+		if (schema.oneOf) return schema.oneOf.some((it) => this.isSchemaNullable(it));
+		if (schema.allOf) return schema.allOf.some((it) => this.isSchemaNullable(it));
+		return false;
+	};
+	onConfigure = $hook({
+		on: "configure",
+		handler: () => {
+			this.useEval = this.canEval();
+		}
+	});
+	canEval() {
+		try {
+			Compile(t.object({ test: t.string() })).Parse({ test: "value" });
+			return true;
+		} catch {
+			return false;
+		}
+	}
+};
+
+//#endregion
+//#region ../../src/core/providers/CodecManager.ts
+/**
+* CodecManager manages multiple codec formats and provides a unified interface
+* for encoding and decoding data with different formats.
+*/
+var CodecManager = class {
+	codecs = /* @__PURE__ */ new Map();
+	jsonCodec = $inject(JsonSchemaCodec);
+	schemaValidator = $inject(SchemaValidator);
+	default = "json";
+	constructor() {
+		this.register(this.default, this.jsonCodec);
+	}
 	/**
-	* True if the App has been configured.
+	* Register a new codec format.
+	*
+	* @param name - The name of the codec (e.g., 'json', 'protobuf')
+	* @param codec - The codec implementation
 	*/
-	configured = false;
+	register(name, codec) {
+		this.codecs.set(name, codec);
+	}
 	/**
-	* True if the App has started.
+	* Get a specific codec by name.
+	*
+	* @param name - The name of the codec
+	* @returns The codec instance
+	* @throws {AlephaError} If the codec is not found
 	*/
-	started = false;
+	getCodec(name) {
+		const codec = this.codecs.get(name);
+		if (!codec) throw new AlephaError(`Codec "${name}" not found. Available codecs: ${Array.from(this.codecs.keys()).join(", ")}`);
+		return codec;
+	}
 	/**
-	* True if the App is ready.
+	* Encode data using the specified codec and output format.
 	*/
-	ready = false;
+	encode(schema, value, options) {
+		const codec = this.getCodec(options?.encoder ?? this.default);
+		const as = options?.as ?? "object";
+		if (options?.validation !== false) value = this.schemaValidator.validate(schema, value, options?.validation);
+		if (as === "object") return value;
+		if (as === "binary") return codec.encodeToBinary(schema, value);
+		return codec.encodeToString(schema, value);
+	}
 	/**
-	* A promise that resolves when the App has started.
+	* Decode data using the specified codec.
 	*/
-	starting;
+	decode(schema, data, options) {
+		const encoderName = options?.encoder ?? this.default;
+		let value = this.getCodec(encoderName).decode(schema, data);
+		if (options?.validation !== false) value = this.schemaValidator.validate(schema, value, options?.validation);
+		return value;
+	}
 	/**
-	* During the instantiation process, we keep a list of pending instantiations.
-	* > It allows us to detect circular dependencies.
+	* Validate decoded data against the schema.
+	*
+	* This is automatically called before encoding or after decoding.
 	*/
-	pendingInstantiations = [];
+	validate(schema, value, options) {
+		return this.schemaValidator.validate(schema, value, options);
+	}
+};
+
+//#endregion
+//#region ../../src/core/providers/EventManager.ts
+var EventManager = class {
+	logFn;
 	/**
-	* Cache for environment variables.
-	* > It allows us to avoid parsing the same schema multiple times.
+	* List of events that can be triggered. Powered by $hook().
 	*/
-	cacheEnv = /* @__PURE__ */ new Map();
-	/**
-	* List of modules that are registered in the container.
-	*
-	* Modules are used to group services and provide a way to register them in the container.
-	*/
-	modules = [];
-	/**
-	* List of service substitutions.
-	*
-	* Services registered here will be replaced by the specified service when injected.
-	*/
-	substitutions = /* @__PURE__ */ new Map();
-	/**
-	* Registry of primitives.
-	*/
-	primitiveRegistry = /* @__PURE__ */ new Map();
-	/**
-	*  List of all services + how they are provided.
-	*/
-	registry = /* @__PURE__ */ new Map();
-	/**
-	* Node.js feature that allows to store context across asynchronous calls.
-	*
-	* This is used for logging, tracing, and other context-related features.
-	*
-	* Mocked for browser environments.
-	*/
-	context;
-	/**
-	* Event manager to handle lifecycle events and custom events.
-	*/
-	events;
-	/**
-	* State manager to store arbitrary values.
-	*/
-	store;
-	/**
-	* Codec manager for encoding and decoding data with different formats.
-	*
-	* Supports multiple codec formats (JSON, Protobuf, etc.) with a unified interface.
-	*/
-	codec;
+	events = {};
+	constructor(logFn) {
+		this.logFn = logFn;
+	}
+	get log() {
+		return this.logFn?.();
+	}
 	/**
-	* Get logger instance.
+	* Registers a hook for the specified event.
 	*/
-	get log() {
-		return this.store.get("alepha.logger");
+	on(event, hookOrFunc) {
+		if (!this.events[event]) this.events[event] = [];
+		const hook = typeof hookOrFunc === "function" ? { callback: hookOrFunc } : hookOrFunc;
+		if (hook.priority === "first") this.events[event].unshift(hook);
+		else if (hook.priority === "last") this.events[event].push(hook);
+		else {
+			const index = this.events[event].findIndex((it) => it.priority === "last");
+			if (index !== -1) this.events[event].splice(index, 0, hook);
+			else this.events[event].push(hook);
+		}
+		return () => {
+			this.events[event] = this.events[event].filter((it) => it.callback !== hook.callback);
+		};
 	}
 	/**
-	* The environment variables for the App.
+	* Emits the specified event with the given payload.
 	*/
-	get env() {
-		return this.store.get("env") ?? {};
+	async emit(func, payload, options = {}) {
+		const ctx = {};
+		if (options.log) {
+			ctx.now = Date.now();
+			this.log?.trace(`${func} ...`);
+		}
+		let events = this.events[func] ?? [];
+		if (options.reverse) events = events.toReversed();
+		for (const hook of events) {
+			const name = hook.caller?.name ?? "unknown";
+			if (options.log) {
+				ctx.now2 = Date.now();
+				this.log?.trace(`${func}(${name}) ...`);
+			}
+			try {
+				await hook.callback(payload);
+			} catch (error) {
+				if (options.catch) {
+					this.log?.error(`${func}(${name}) ERROR`, error);
+					continue;
+				}
+				if (options.log) throw new AlephaError(`Failed during '${func}()' hook for service: ${name}`, { cause: error });
+				throw error;
+			}
+			if (options.log) this.log?.debug(`${func}(${name}) OK [${Date.now() - ctx.now2}ms]`);
+		}
+		if (options.log) this.log?.debug(`${func} OK [${Date.now() - ctx.now}ms]`);
 	}
-	constructor(state = {}) {
-		this.store = this.inject(StateManager, { args: [state] });
-		this.events = this.inject(EventManager);
-		this.events.logFn = () => this.log;
-		this.context = this.inject(AlsProvider);
-		this.codec = this.inject(CodecManager);
+};
+
+//#endregion
+//#region ../../src/core/primitives/$atom.ts
+/**
+* Define an atom for state management.
+*
+* Atom lets you define a piece of state with a name, schema, and default value.
+*
+* By default, Alepha state is just a simple key-value store.
+* Using atoms allows you to have type safety, validation, and default values for your state.
+*
+* You control how state is structured and validated.
+*
+* Features:
+* - Set a schema for validation
+* - Set a default value for initial state
+* - Rules, like read-only, custom validation, etc.
+* - Automatic getter access in services with {@link $use}
+* - SSR support (server state automatically serialized and hydrated on client)
+* - React integration (useAtom hook for automatic component re-renders)
+* - Middleware
+* - Persistence adapters (localStorage, Redis, database, file system, cookie, etc.)
+* - State migrations (version upgrades when schema changes)
+* - Documentation generation & devtools integration
+*
+* Common use cases:
+* - user preferences
+* - feature flags
+* - configuration options
+* - session data
+*
+* Atom must contain only serializable data.
+* Avoid storing complex objects like class instances, functions, or DOM elements.
+* If you need to store complex data, consider using identifiers or references instead.
+*/
+const $atom = (options) => {
+	return new Atom(options);
+};
+var Atom = class {
+	options;
+	get schema() {
+		return this.options.schema;
 	}
-	set(target, value) {
-		this.store.set(target, value);
+	get key() {
+		return this.options.name;
+	}
+	constructor(options) {
+		this.options = options;
+	}
+};
+$atom[KIND] = "atom";
+
+//#endregion
+//#region ../../src/core/providers/StateManager.ts
+var StateManager = class {
+	als = $inject(AlsProvider);
+	events = $inject(EventManager);
+	codec = $inject(JsonSchemaCodec);
+	atoms = /* @__PURE__ */ new Map();
+	store = {};
+	constructor(store = {}) {
+		this.store = store;
+	}
+	getAtoms(context = true) {
+		const atoms = [];
+		if (context && this.als?.exists()) for (const atom of this.atoms.values()) {
+			const value = this.als.get(atom.key);
+			if (value !== void 0) atoms.push({
+				atom,
+				value
+			});
+		}
+		else for (const [key, atom] of this.atoms.entries()) atoms.push({
+			atom,
+			value: this.store[key]
+		});
+		return atoms;
+	}
+	register(atom) {
+		const key = atom.key;
+		if (!this.atoms.has(key)) {
+			this.atoms.set(key, atom);
+			if (!(key in this.store)) this.set(key, atom.options.default, { skipContext: true });
+		}
 		return this;
 	}
-	/**
-	* True when start() is called.
-	*
-	* -> No more services can be added, it's over, bye!
-	*/
-	isLocked() {
-		return this.locked;
+	get(target) {
+		if (target instanceof Atom) this.register(target);
+		const key = target instanceof Atom ? target.key : target;
+		const store = this.store;
+		return this.als?.exists() ? this.als.get(key) ?? store[key] : store[key];
 	}
-	/**
-	* Returns whether the App is configured.
-	*
-	* It means that Alepha#configure() has been called.
-	*
-	* > By default, configure() is called automatically when start() is called, but you can also call it manually.
-	*/
-	isConfigured() {
-		return this.configured;
+	set(target, value, options) {
+		if (target instanceof Atom) this.register(target);
+		const key = target instanceof Atom ? target.key : target;
+		const store = this.store;
+		const prevValue = this.get(key);
+		if (prevValue === value) return this;
+		if (options?.skipContext !== true && this.als?.exists()) this.als.set(key, value);
+		else store[key] = value;
+		if (options?.skipEvents !== true) this.events?.emit("state:mutate", {
+			key,
+			value,
+			prevValue
+		}, { catch: true }).catch(() => null);
+		return this;
+	}
+	mut(target, mutator) {
+		const updated = mutator(this.get(target));
+		return this.set(target, updated);
 	}
 	/**
-	* Returns whether the App has started.
-	*
-	* It means that #start() has been called but maybe not all services are ready.
+	* Check if a key exists in the state
 	*/
-	isStarted() {
-		return this.started;
+	has(key) {
+		return key in this.store;
 	}
 	/**
-	* True if the App is ready. It means that Alepha is started AND ready() hook has beed called.
+	* Delete a key from the state (set to undefined)
 	*/
-	isReady() {
-		return this.ready;
+	del(key) {
+		return this.set(key, void 0);
 	}
 	/**
-	* True if the App is running in a Continuous Integration environment.
+	* Push a value to an array in the state
 	*/
-	isCI() {
-		if (this.env.GITHUB_ACTIONS) return true;
-		return !!this.env.CI;
+	push(key, ...value) {
+		const current = this.get(key) ?? [];
+		if (Array.isArray(current)) this.set(key, [...current, ...value]);
+		return this;
 	}
 	/**
-	* True if the App is running in a browser environment.
+	* Clear all state
 	*/
-	isBrowser() {
-		return typeof window !== "undefined";
+	clear() {
+		this.store = {};
+		return this;
 	}
 	/**
-	* Returns whether the App is running in Vite dev mode.
-	*/
-	isViteDev() {
-		if (this.isBrowser()) return false;
-		return !!this.env.VITE_ALEPHA_DEV;
-	}
-	isBun() {
-		return "Bun" in globalThis;
-	}
-	/**
-	* Returns whether the App is running in a serverless environment.
-	*/
-	isServerless() {
-		if (this.isBrowser()) return false;
-		if (this.env.VERCEL_REGION) return true;
-		if (typeof global === "object" && typeof global.Cloudflare === "object") return true;
-		return false;
-	}
-	/**
-	* Returns whether the App is in test mode. (Running in a test environment)
-	*
-	* > This is automatically set when running tests with Jest or Vitest.
-	*/
-	isTest() {
-		return this.env.NODE_ENV === "test";
-	}
-	/**
-	* Returns whether the App is in production mode. (Running in a production environment)
-	*
-	* > This is automatically set by Vite or Vercel. However, you have to set it manually when running Docker apps.
-	*/
-	isProduction() {
-		return this.env.NODE_ENV === "production";
-	}
-	/**
-	* Starts the App.
-	*
-	* - Lock any further changes to the container.
-	* - Run "configure" hook for all services. Primitives will be processed.
-	* - Run "start" hook for all services. Providers will connect/listen/...
-	* - Run "ready" hook for all services. This is the point where the App is ready to serve requests.
-	*
-	* @return A promise that resolves when the App has started.
-	*/
-	async start() {
-		if (this.ready) {
-			this.log?.debug("App is already started, skipping...");
-			return this;
-		}
-		if (this.starting) {
-			this.log?.warn("App is already starting, waiting for it to finish...");
-			return this.starting.promise;
-		}
-		this.starting = Promise.withResolvers();
-		const now = Date.now();
-		this.log?.info("Starting App...");
-		for (const [key] of this.substitutions.entries()) this.inject(key);
-		const target = this.store.get("alepha.target");
-		if (target) {
-			this.registry = /* @__PURE__ */ new Map();
-			this.primitiveRegistry = /* @__PURE__ */ new Map();
-			this.with(target);
-		}
-		this.locked = true;
-		await this.events.emit("configure", this, { log: true });
-		this.configured = true;
-		await this.events.emit("start", this, { log: true });
-		this.started = true;
-		await this.events.emit("ready", this, { log: true });
-		this.log?.info(`App is now ready [${Date.now() - now}ms]`);
-		this.ready = true;
-		this.starting.resolve(this);
-		this.starting = void 0;
-		return this;
-	}
-	/**
-	* Stops the App.
-	*
-	* - Run "stop" hook for all services.
-	*
-	* Stop will NOT reset the container.
-	* Stop will NOT unlock the container.
-	*
-	* > Stop is used to gracefully shut down the application, nothing more. There is no "restart".
-	*
-	* @return A promise that resolves when the App has stopped.
-	*/
-	async stop() {
-		if (!this.started) return;
-		this.log?.info("Stopping App...");
-		await this.events.emit("stop", this, {
-			reverse: true,
-			log: true
-		});
-		this.log?.info("App is now off");
-		this.started = false;
-		this.ready = false;
-	}
-	/**
-	* Check if entry is registered in the container.
-	*/
-	has(entry, opts = {}) {
-		if (entry === Alepha) return true;
-		const { inStack = true, inRegistry = true, inSubstitutions = true, registry = this.registry } = opts;
-		const { provide } = typeof entry === "object" && "provide" in entry ? entry : { provide: entry };
-		if (inSubstitutions) {
-			if (this.substitutions.get(provide)) return true;
-		}
-		if (inRegistry) {
-			if (registry.get(provide)) return true;
-		}
-		if (inStack) {
-			const substitute = this.substitutions.get(provide)?.use;
-			if (substitute && this.pendingInstantiations.includes(substitute)) return true;
-			return this.pendingInstantiations.includes(provide);
-		}
-		return false;
-	}
-	/**
-	* Registers the specified service in the container.
-	*
-	* - If the service is ALREADY registered, the method does nothing.
-	* - If the service is NOT registered, a new instance is created and registered.
-	*
-	* Method is chainable, so you can register multiple services in a single call.
-	*
-	* > ServiceEntry allows to provide a service **substitution** feature.
-	*
-	* @example
-	* ```ts
-	* class A { value = "a"; }
-	* class B { value = "b"; }
-	* class M { a = $inject(A); }
-	*
-	* Alepha.create().with({ provide: A, use: B }).get(M).a.value; // "b"
-	* ```
-	*
-	* > **Substitution** is an advanced feature that allows you to replace a service with another service.
-	* > It's useful for testing or for providing different implementations of a service.
-	* > If you are interested in configuring a service, use Alepha#configure() instead.
-	*
-	* @param serviceEntry - The service to register in the container.
-	* @return Current instance of Alepha.
-	*/
-	with(serviceEntry) {
-		const entry = "default" in serviceEntry ? serviceEntry.default : serviceEntry;
-		if (this.has(entry, {
-			inSubstitutions: false,
-			inRegistry: false
-		})) return this;
-		if (typeof entry === "object") {
-			if (entry.provide === entry.use) {
-				this.inject(entry.provide);
-				return this;
-			}
-			if (!this.substitutions.has(entry.provide) && !this.has(entry.provide)) {
-				if (this.started) throw new ContainerLockedError();
-				if (MODULE in entry.provide && typeof entry.provide[MODULE] === "function") entry.use[MODULE] ??= entry.provide[MODULE];
-				this.substitutions.set(entry.provide, { use: entry.use });
-			} else if (!entry.optional) throw new TooLateSubstitutionError(entry.provide.name, entry.use.name);
-			return this;
-		}
-		this.inject(entry);
-		return this;
-	}
-	/**
-	* Get an instance of the specified service from the container.
-	*
-	* @see {@link InjectOptions} for the available options.
-	*/
-	inject(service, opts = {}) {
-		const lifetime = opts.lifetime ?? "singleton";
-		const parent = opts.parent !== void 0 ? opts.parent : __alephaRef?.parent ?? Alepha;
-		const transient = lifetime === "transient";
-		const registry = lifetime === "scoped" ? this.context.get("registry") ?? this.registry : this.registry;
-		if (service === Alepha) return this;
-		if (typeof service === "string") {
-			for (const [key, value] of registry.entries()) if (key.name === service) return value.instance;
-			throw new AlephaError(`Service not found: ${service}`);
-		}
-		const substitute = this.substitutions.get(service);
-		if (substitute) return this.inject(substitute.use, {
-			parent,
-			lifetime
-		});
-		const index = this.pendingInstantiations.indexOf(service);
-		if (index !== -1 && !transient) throw new CircularDependencyError(service.name, this.pendingInstantiations.slice(0, index).map((it) => it.name));
-		if (!transient) {
-			const match = registry.get(service);
-			if (match) {
-				if (!match.parents.includes(parent) && parent !== service) match.parents.push(parent);
-				return match.instance;
-			}
-			if (this.started) throw new ContainerLockedError(`Container is locked. No more services can be added. ${parent?.name} -> ${service.name}`);
-		}
-		const module = service[MODULE];
-		if (module && typeof module === "function") this.with(module);
-		if (this.has(service, { registry }) && !transient) return this.inject(service, {
-			parent,
-			lifetime
-		});
-		const instance = this.new(service, opts.args);
-		const definition = {
-			parents: [parent],
-			instance
-		};
-		if (!transient) registry.set(service, definition);
-		if (instance instanceof Module) {
-			this.modules.push(instance);
-			const parent$1 = __alephaRef.parent;
-			__alephaRef.parent = instance.constructor;
-			instance.register(this);
-			__alephaRef.parent = parent$1;
-		}
-		return instance;
-	}
-	/**
-	* Applies environment variables to the provided schema and state object.
-	*
-	* It replaces also all templated $ENV inside string values.
-	*
-	* @param schema - The schema object to apply environment variables to.
-	* @return The schema object with environment variables applied.
-	*/
-	parseEnv(schema) {
-		if (this.cacheEnv.has(schema)) return this.cacheEnv.get(schema);
-		const config = this.codec.validate(schema, this.env);
-		for (const key in config) if (typeof config[key] === "string") for (const env in config) config[key] = config[key].replace(new RegExp(`\\$${env}`, "gim"), config[env]);
-		this.cacheEnv.set(schema, config);
-		return config;
-	}
-	/**
-	* Get all environment variable schemas and their parsed values.
-	*
-	* This is useful for DevTools to display all expected environment variables.
-	*/
-	getEnvSchemas() {
-		const result = [];
-		for (const [schema, values] of this.cacheEnv.entries()) result.push({
-			schema,
-			values
-		});
-		return result;
-	}
-	/**
-	* Dump the current dependency graph of the App.
-	*
-	* This method returns a record where the keys are the names of the services.
-	*/
-	graph() {
-		for (const [key] of this.substitutions.entries()) if (!this.has(key)) this.inject(key);
-		const graph = {};
-		for (const [provide, { parents }] of this.registry.entries()) {
-			graph[provide.name] = { from: parents.filter((it) => !!it).map((it) => it.name) };
-			const aliases = this.substitutions.entries().filter((it) => it[1].use === provide).map((it) => it[0].name).toArray();
-			if (aliases.length) graph[provide.name].as = aliases;
-			const module = Module.of(provide);
-			if (module) graph[provide.name].module = module.name;
-		}
-		return graph;
-	}
-	services(base) {
-		const list = [];
-		for (const [key, value] of this.registry.entries()) if (value.instance instanceof base) list.push(value.instance);
-		return list;
-	}
-	/**
-	* Get all primitives of the specified type.
+	* Get all keys that exist in the state
 	*/
-	primitives(factory) {
-		if (typeof factory === "string") {
-			const key1 = factory.toLowerCase().replace("$", "");
-			const key2 = `${key1}primitive`;
-			for (const [key, value] of this.primitiveRegistry.entries()) {
-				const name = key.name.toLowerCase();
-				if (name === key1 || name === key2) return value;
-			}
-			return [];
-		}
-		return this.primitiveRegistry.get(factory[KIND]) ?? [];
-	}
-	new(service, args = []) {
-		this.pendingInstantiations.push(service);
-		__alephaRef.alepha = this;
-		__alephaRef.service = service;
-		const instance = isClass(service) ? new service(...args) : service(...args) ?? {};
-		const obj = instance;
-		for (const [key, value] of Object.entries(obj)) {
-			if (value instanceof Primitive) this.processPrimitive(value, key);
-			if (typeof value === "object" && value !== null && typeof value[OPTIONS] === "object" && "getter" in value[OPTIONS]) {
-				const getter = value[OPTIONS].getter;
-				Object.defineProperty(obj, key, { get: () => this.store.get(getter) });
-			}
-		}
-		this.pendingInstantiations.pop();
-		if (this.pendingInstantiations.length === 0) __alephaRef.alepha = void 0;
-		__alephaRef.service = this.pendingInstantiations[this.pendingInstantiations.length - 1];
-		return instance;
-	}
-	processPrimitive(value, propertyKey = "") {
-		value.config.propertyKey = propertyKey;
-		value.onInit();
-		const kind = value.constructor;
-		const list = this.primitiveRegistry.get(kind) ?? [];
-		this.primitiveRegistry.set(kind, [...list, value]);
-	}
-};
-
-//#endregion
-//#region ../../src/core/errors/AppNotStartedError.ts
-var AppNotStartedError = class extends AlephaError {
-	name = "AppNotStartedError";
-	constructor() {
-		super("App not started. Please start the app before.");
+	keys() {
+		return Object.keys(this.store);
 	}
 };
 
 //#endregion
-//#region ../../src/core/helpers/createPagination.ts
+//#region ../../src/core/Alepha.ts
 /**
-* Create a pagination object from an array of entities.
+* Core container of the Alepha framework.
+*
+* It is responsible for managing the lifecycle of services,
+* handling dependency injection,
+* and providing a unified interface for the application.
+*
+* @example
+* ```ts
+* import { Alepha, run } from "alepha";
+*
+* class MyService {
+*   // business logic here
+* }
+*
+* const alepha = Alepha.create({
+*   // state, env, and other properties
+* })
+*
+* alepha.with(MyService);
+*
+* run(alepha); // trigger .start (and .stop) automatically
+* ```
+*
+* ### Alepha Factory
+*
+* Alepha.create() is an enhanced version of new Alepha().
+* - It merges `process.env` with the provided state.env when available.
+* - It populates the test hooks for Vitest or Jest environments when available.
 *
-* This is a pure function that works with any data source (databases, APIs, caches, arrays, etc.).
-* It handles the core pagination logic including:
-* - Slicing the content to the requested page size
-* - Calculating pagination metadata (offset, page number, etc.)
-* - Determining navigation state (isFirst, isLast)
-* - Including sort metadata when provided
+* new Alepha() is fine if you don't need these helpers.
 *
-* @param entities - The entities to paginate (should include one extra item to detect if there's a next page)
-* @param limit - The limit of the pagination (page size)
-* @param offset - The offset of the pagination (starting position)
-* @param sort - Optional sort metadata to include in response
-* @returns A complete Page object with content and metadata
+* ### Platforms & Environments
+*
+* Alepha is designed to work in various environments:
+* - **Browser**: Runs in the browser, using the global `window` object.
+* - **Serverless**: Runs in serverless environments like Vercel or Vite.
+* - **Test**: Runs in test environments like Jest or Vitest.
+* - **Production**: Runs in production environments, typically with NODE_ENV set to "production".
+* * You can check the current environment using the following methods:
+*
+* - `isBrowser()`: Returns true if the App is running in a browser environment.
+* - `isServerless()`: Returns true if the App is running in a serverless environment.
+* - `isTest()`: Returns true if the App is running in a test environment.
+* - `isProduction()`: Returns true if the App is running in a production environment.
+*
+* ### State & Environment
+*
+* The state of the Alepha container is stored in the `store` property.
+* Most important property is `store.env`, which contains the environment variables.
 *
-* @example Basic pagination
 * ```ts
-* const users = await fetchUsers({ limit: 11, offset: 0 }); // Fetch limit + 1
-* const page = createPagination(users, 10, 0);
-* // page.content has max 10 items
-* // page.page.isLast tells us if there are more pages
+* const alepha = Alepha.create({ env: { MY_VAR: "value" } });
+*
+* // You can access the environment variables using alepha.env
+* console.log(alepha.env.MY_VAR); // "value"
+*
+* // But you should use $env() primitive to get typed values from the environment.
+* class App {
+*   env = $env(
+*     t.object({
+*  	   MY_VAR: t.text(),
+*     })
+*   );
+* }
 * ```
 *
-* @example With sorting
+* ### Modules
+*
+* Modules are a way to group services together.
+* You can register a module using the `$module` primitive.
+*
 * ```ts
-* const page = createPagination(
-*   entities,
-*   10,
-*   0,
-*   [{ column: "name", direction: "asc" }]
-* );
+* import { $module } from "alepha";
+*
+* class MyLib {}
+*
+* const myModule = $module({
+*   name: "my.project.module",
+*   services: [MyLib],
+* });
 * ```
 *
-* @example In a custom service
+* Do not use modules for small applications.
+*
+* ### Hooks
+*
+* Hooks are a way to run async functions from all registered providers/services.
+* You can register a hook using the `$hook` primitive.
+*
 * ```ts
-* class MyService {
-*   async listItems(page: number, size: number) {
-*     const items = await this.fetchItems({ limit: size + 1, offset: page * size });
-*     return createPagination(items, size, page * size);
-*   }
-* }
+* import { $hook } from "alepha";
+*
+* class App {
+* 	 log = $logger();
+* 	 onCustomerHook = $hook({
+* 			on: "my:custom:hook",
+* 			handler: () => {
+* 		 	  this.log?.info("App is being configured");
+* 	 		},
+* 	  });
+* 	}
+*
+* Alepha.create()
+* 	 .with(App)
+* 	 .start()
+* 	 .then(alepha => alepha.events.emit("my:custom:hook"));
 * ```
+*
+* 	Hooks are fully typed. You can create your own hooks by using module augmentation:
+*
+* 	```ts
+* 	declare module "alepha" {
+* 		interface Hooks {
+* 		  "my:custom:hook": {
+* 				arg1: string;
+* 		  }
+* 		}
+* 	}
+* 	```
+*
+* 	@module alepha
 */
-function createPagination(entities, limit = 10, offset = 0, sort) {
-	const content = entities.slice(0, limit);
-	const hasNext = entities.length === limit + 1;
-	const pageNumber = Math.floor(offset / limit);
-	return {
-		content,
-		page: {
-			number: pageNumber,
-			size: limit,
-			offset,
-			numberOfElements: content.length,
-			isEmpty: content.length === 0,
-			isFirst: pageNumber === 0,
-			isLast: !hasNext,
-			...sort && sort.length > 0 ? { sort: {
-				sorted: true,
-				fields: sort.map((s) => ({
-					field: s.column,
-					direction: s.direction
-				}))
-			} } : {}
-		}
-	};
-}
-
-//#endregion
-//#region ../../src/core/helpers/FileLike.ts
-const isTypeFile = (value) => {
-	return value && typeof value === "object" && "format" in value && value.format === "binary";
-};
-const isFileLike = (value) => {
-	return !!value && typeof value === "object" && !Array.isArray(value) && typeof value.name === "string" && typeof value.type === "string" && typeof value.size === "number" && typeof value.stream.bind(value) === "function";
-};
-
-//#endregion
-//#region ../../src/core/providers/TypeProvider.ts
-const isUUID = Format.IsUuid;
-var TypeGuard = class {
-	isBigInt = (value) => Type.IsString(value) && "format" in value && value.format === "bigint";
-	isUUID = (value) => Type.IsString(value) && "format" in value && value.format === "uuid";
-	isObject = Type.IsObject;
-	isNumber = Type.IsNumber;
-	isString = Type.IsString;
-	isBoolean = Type.IsBoolean;
-	isAny = Type.IsAny;
-	isArray = Type.IsArray;
-	isOptional = Type.IsOptional;
-	isUnion = Type.IsUnion;
-	isInteger = Type.IsInteger;
-	isNull = Type.IsNull;
-	isUndefined = Type.IsUndefined;
-	isUnsafe = Type.IsUnsafe;
-	isRecord = Type.IsRecord;
-	isTuple = Type.IsTuple;
-	isVoid = Type.IsVoid;
-	isLiteral = Type.IsLiteral;
-	isSchema = Type.IsSchema;
-	isFile = isTypeFile;
-	isDateTime = (schema) => {
-		return t.schema.isString(schema) && schema.format === "date-time";
-	};
-	isDate = (schema) => {
-		return t.schema.isString(schema) && schema.format === "date";
-	};
-	isTime = (schema) => {
-		return t.schema.isString(schema) && schema.format === "time";
-	};
-	isDuration = (schema) => {
-		return t.schema.isString(schema) && schema.format === "duration";
-	};
-};
-var TypeProvider = class TypeProvider {
-	static format = Format;
-	static {
-		Format.Set("bigint", (value) => TypeProvider.isValidBigInt(value));
-	}
-	static translateError(error, locale) {
-		if (!locale) return error.cause.message;
-		for (const [key, value] of Object.entries(Locale)) {
-			if (key === "Set" || key === "Get" || key === "Reset") continue;
-			if (key === locale || key.startsWith(`${locale}_`)) return value(error.cause);
-		}
-		return error.cause.message;
-	}
-	static setLocale(locale) {
-		for (const [key, value] of Object.entries(Locale)) {
-			if (key === "Set" || key === "Get" || key === "Reset") continue;
-			if (key === locale || key.startsWith(`${locale}_`)) {
-				Locale.Set(value);
-				return;
-			}
+var Alepha = class Alepha {
+	/**
+	* Creates a new instance of the Alepha container with some helpers:
+	*
+	* - merges `process.env` with the provided state.env when available.
+	* - populates the test hooks for Vitest or Jest environments when available.
+	*
+	* If you are not interested about these helpers, you can use the constructor directly.
+	*/
+	static create(state = {}) {
+		if (typeof process === "object" && typeof process.env === "object") {
+			state.env = {
+				...state.env,
+				...process.env
+			};
+			if (process.env.NODE_ENV === "production") state.env.NODE_ENV ??= "production";
 		}
-		throw new AlephaError(`Locale not found: ${locale}`);
-	}
-	static isValidBigInt(value) {
-		if (typeof value === "number") return Number.isInteger(value);
-		if (!value.trim()) return false;
-		if (!/^-?\d+$/.test(value)) return false;
-		try {
-			BigInt(value);
-			return true;
-		} catch {
-			return false;
+		const alepha = new Alepha(state);
+		if (alepha.isTest()) {
+			const g = globalThis;
+			const beforeAll = state["alepha.test.beforeAll"] ?? g.beforeAll;
+			const afterAll = state["alepha.test.afterAll"] ?? g.afterAll;
+			const afterEach = state["alepha.test.afterEach"] ?? g.afterEach;
+			const onTestFinished = state["alepha.test.onTestFinished"] ?? g.onTestFinished;
+			beforeAll?.(() => alepha.start());
+			afterAll?.(() => alepha.stop());
+			try {
+				onTestFinished?.(() => alepha.stop());
+			} catch (_error) {}
+			alepha.store.set("alepha.test.beforeAll", beforeAll).set("alepha.test.afterAll", afterAll).set("alepha.test.afterEach", afterEach).set("alepha.test.onTestFinished", onTestFinished);
 		}
+		return alepha;
 	}
 	/**
-	* Default maximum length for strings.
-	*
-	* It can be set to a larger value:
-	* ```ts
-	* TypeProvider.DEFAULT_STRING_MAX_LENGTH = 1000000;
-	* TypeProvider.DEFAULT_STRING_MAX_LENGTH = undefined; // no limit (not recommended)
-	* ```
+	* Flag indicating whether the App won't accept any further changes.
+	* Pass to true when #start() is called.
+	*/
+	locked = false;
+	/**
+	* True if the App has been configured.
+	*/
+	configured = false;
+	/**
+	* True if the App has started.
+	*/
+	started = false;
+	/**
+	* True if the App is ready.
 	*/
-	static DEFAULT_STRING_MAX_LENGTH = 255;
+	ready = false;
 	/**
-	* Maximum length for short strings, such as names or titles.
+	* A promise that resolves when the App has started.
 	*/
-	static DEFAULT_SHORT_STRING_MAX_LENGTH = 64;
+	starting;
 	/**
-	* Maximum length for long strings, such as descriptions or comments.
-	* It can be overridden in the string options.
-	*
-	* It can be set to a larger value:
-	* ```ts
-	* TypeProvider.DEFAULT_LONG_STRING_MAX_LENGTH = 2048;
-	* ```
+	* During the instantiation process, we keep a list of pending instantiations.
+	* > It allows us to detect circular dependencies.
 	*/
-	static DEFAULT_LONG_STRING_MAX_LENGTH = 1024;
+	pendingInstantiations = [];
 	/**
-	* Maximum length for rich strings, such as HTML or Markdown.
-	* This is a large value to accommodate rich text content.
-	* > It's also the maximum length of PG's TEXT type.
+	* Cache for environment variables.
+	* > It allows us to avoid parsing the same schema multiple times.
+	*/
+	cacheEnv = /* @__PURE__ */ new Map();
+	/**
+	* List of modules that are registered in the container.
 	*
-	* It can be overridden in the string options.
+	* Modules are used to group services and provide a way to register them in the container.
+	*/
+	modules = [];
+	/**
+	* List of service substitutions.
 	*
-	* It can be set to a larger value:
-	* ```ts
-	* TypeProvider.DEFAULT_RICH_STRING_MAX_LENGTH = 1000000;
-	* ```
+	* Services registered here will be replaced by the specified service when injected.
 	*/
-	static DEFAULT_RICH_STRING_MAX_LENGTH = 65535;
+	substitutions = /* @__PURE__ */ new Map();
 	/**
-	* Maximum number of items in an array.
-	* This is a default value to prevent excessive memory usage.
-	* It can be overridden in the array options.
+	* Registry of primitives.
 	*/
-	static DEFAULT_ARRAY_MAX_ITEMS = 1e3;
-	raw = Type;
-	any = Type.Any;
-	void = Type.Void;
-	undefined = Type.Undefined;
-	record = Type.Record;
-	union = Type.Union;
-	tuple = Type.Tuple;
-	null = Type.Null;
-	const = Type.Literal;
-	options = Type.Options;
+	primitiveRegistry = /* @__PURE__ */ new Map();
 	/**
-	* Type guards to check the type of schema.
-	* This is not a runtime type check, but a compile-time type guard.
-	*
-	* @example
-	* ```ts
-	* if (t.schema.isString(schema)) {
-	*   // schema is TString
-	* }
-	* ```
+	*  List of all services + how they are provided.
 	*/
-	schema = new TypeGuard();
-	extend(schema, properties, options) {
-		return Type.Interface(Array.isArray(schema) ? schema : [schema], properties, {
-			additionalProperties: false,
-			...options
-		});
-	}
-	pick(schema, keys, options) {
-		return Type.Pick(schema, keys, {
-			additionalProperties: false,
-			...options
-		});
-	}
-	omit(schema, keys, options) {
-		return Type.Omit(schema, keys, {
-			additionalProperties: false,
-			...options
-		});
-	}
-	partial(schema, options) {
-		return Type.Partial(schema, {
-			additionalProperties: false,
-			...options
-		});
-	}
+	registry = /* @__PURE__ */ new Map();
 	/**
-	* Create a schema for an object.
-	* By default, additional properties are not allowed.
+	* Node.js feature that allows to store context across asynchronous calls.
 	*
-	* @example
-	* ```ts
-	* const userSchema = t.object({
-	*   id: t.integer(),
-	*   name: t.string(),
-	* });
-	* ```
+	* This is used for logging, tracing, and other context-related features.
+	*
+	* Mocked for browser environments.
 	*/
-	object(properties, options) {
-		return Type.Object(properties, {
-			additionalProperties: false,
-			...options
-		});
-	}
+	context;
 	/**
-	* Create a schema for an array.
-	* By default, the maximum number of items is limited to prevent excessive memory usage.
+	* Event manager to handle lifecycle events and custom events.
+	*/
+	events;
+	/**
+	* State manager to store arbitrary values.
+	*/
+	store;
+	/**
+	* Codec manager for encoding and decoding data with different formats.
 	*
-	* @see TypeProvider.DEFAULT_ARRAY_MAX_ITEMS
+	* Supports multiple codec formats (JSON, Protobuf, etc.) with a unified interface.
 	*/
-	array(schema, options) {
-		return Type.Array(schema, {
-			maxItems: TypeProvider.DEFAULT_ARRAY_MAX_ITEMS,
-			...options
-		});
+	codec;
+	/**
+	* Get logger instance.
+	*/
+	get log() {
+		return this.store.get("alepha.logger");
 	}
 	/**
-	* Create a schema for a string.
-	* For db or input fields, consider using `t.text()` instead, which has length limits.
-	*
-	* If you need a string with specific format (e.g. email, uuid), consider using the corresponding method (e.g. `t.email()`, `t.uuid()`).
+	* The environment variables for the App.
 	*/
-	string(options = {}) {
-		return Type.String({ ...options });
+	get env() {
+		return this.store.get("env") ?? {};
+	}
+	constructor(state = {}) {
+		this.store = this.inject(StateManager, { args: [state] });
+		this.events = this.inject(EventManager);
+		this.events.logFn = () => this.log;
+		this.context = this.inject(AlsProvider);
+		this.codec = this.inject(CodecManager);
+	}
+	set(target, value) {
+		this.store.set(target, value);
+		return this;
 	}
 	/**
-	* Create a schema for a string with length limits.
-	* For internal strings without length limits, consider using `t.string()` instead.
+	* True when start() is called.
 	*
-	* Default size is "regular", which has a max length of 255 characters.
+	* -> No more services can be added, it's over, bye!
 	*/
-	text(options = {}) {
-		const { size, ...rest } = options;
-		const maxLength = size === "short" ? TypeProvider.DEFAULT_SHORT_STRING_MAX_LENGTH : size === "long" ? TypeProvider.DEFAULT_LONG_STRING_MAX_LENGTH : size === "rich" ? TypeProvider.DEFAULT_RICH_STRING_MAX_LENGTH : TypeProvider.DEFAULT_STRING_MAX_LENGTH;
-		return Type.String({
-			maxLength,
-			"~options": {
-				trim: options.trim ?? true,
-				lowercase: options.lowercase ?? false
-			},
-			...rest
-		});
+	isLocked() {
+		return this.locked;
 	}
 	/**
-	* Create a schema for a JSON object.
-	* This is a record with string keys and any values.
+	* Returns whether the App is configured.
+	*
+	* It means that Alepha#configure() has been called.
+	*
+	* > By default, configure() is called automatically when start() is called, but you can also call it manually.
 	*/
-	json(options) {
-		return t.record(t.text(), t.any(), options);
+	isConfigured() {
+		return this.configured;
 	}
 	/**
-	* Create a schema for a boolean.
+	* Returns whether the App has started.
+	*
+	* It means that #start() has been called but maybe not all services are ready.
 	*/
-	boolean(options) {
-		return Type.Boolean({ ...options });
+	isStarted() {
+		return this.started;
 	}
 	/**
-	* Create a schema for a number.
+	* True if the App is ready. It means that Alepha is started AND ready() hook has beed called.
 	*/
-	number(options) {
-		return Type.Number({ ...options });
+	isReady() {
+		return this.ready;
 	}
 	/**
-	* Create a schema for an integer.
+	* True if the App is running in a Continuous Integration environment.
 	*/
-	integer(options) {
-		return Type.Integer({ ...options });
-	}
-	int32(options) {
-		return Type.Integer({
-			minimum: -2147483647,
-			maximum: 2147483647,
-			...options
-		});
+	isCI() {
+		if (this.env.GITHUB_ACTIONS) return true;
+		return !!this.env.CI;
 	}
 	/**
-	* Mimic a signed 64-bit integer.
-	*
-	* This is NOT a true int64, as JavaScript cannot represent all int64 values.
-	* It is a number that is an integer and between -9007199254740991 and 9007199254740991.
-	* Use `t.bigint()` for true int64 values represented as strings.
+	* True if the App is running in a browser environment.
 	*/
-	int64(options) {
-		return Type.Number({
-			format: "int64",
-			multipleOf: 1,
-			minimum: -9007199254740991,
-			maximum: 9007199254740991,
-			...options
-		});
+	isBrowser() {
+		return typeof window !== "undefined";
 	}
 	/**
-	* Make a schema optional.
+	* Returns whether the App is running in Vite dev mode.
 	*/
-	optional(schema) {
-		return Type.Optional(schema);
+	isViteDev() {
+		if (this.isBrowser()) return false;
+		return !!this.env.VITE_ALEPHA_DEV;
+	}
+	isBun() {
+		return "Bun" in globalThis;
 	}
 	/**
-	* Make a schema nullable.
+	* Returns whether the App is running in a serverless environment.
 	*/
-	nullable(schema, options) {
-		return Type.Union([Type.Null(), schema], options);
+	isServerless() {
+		if (this.isBrowser()) return false;
+		if (this.env.VERCEL_REGION) return true;
+		if (typeof global === "object" && typeof global.Cloudflare === "object") return true;
+		return false;
 	}
 	/**
-	* Create a schema that maps all properties of an object schema to nullable.
-	*/
-	nullify = (schema, options) => Type.Mapped(Type.Identifier("K"), Type.KeyOf(schema), Type.Ref("K"), Type.Union([Type.Index(schema, Type.Ref("K")), Type.Null()]), options);
-	/**
-	* Create a schema for a string enum.
+	* Returns whether the App is in test mode. (Running in a test environment)
+	*
+	* > This is automatically set when running tests with Jest or Vitest.
 	*/
-	enum(values, options) {
-		return Type.Unsafe(t.text({
-			enum: values,
-			pattern: values.map((v) => `^${v}$`).join("|"),
-			...options
-		}));
+	isTest() {
+		return this.env.NODE_ENV === "test";
 	}
 	/**
-	* Create a schema for a bigint represented as a string.
-	* This is a string that validates bigint format (e.g. "123456789").
+	* Returns whether the App is in production mode. (Running in a production environment)
+	*
+	* > This is automatically set by Vite or Vercel. However, you have to set it manually when running Docker apps.
 	*/
-	bigint(options) {
-		return t.string({
-			...options,
-			format: "bigint"
-		});
+	isProduction() {
+		return this.env.NODE_ENV === "production";
 	}
 	/**
-	* Create a schema for a URL represented as a string.
+	* Starts the App.
+	*
+	* - Lock any further changes to the container.
+	* - Run "configure" hook for all services. Primitives will be processed.
+	* - Run "start" hook for all services. Providers will connect/listen/...
+	* - Run "ready" hook for all services. This is the point where the App is ready to serve requests.
+	*
+	* @return A promise that resolves when the App has started.
 	*/
-	url(options) {
-		return this.string({
-			...options,
-			format: "url"
-		});
+	async start() {
+		if (this.ready) {
+			this.log?.debug("App is already started, skipping...");
+			return this;
+		}
+		if (this.starting) {
+			this.log?.warn("App is already starting, waiting for it to finish...");
+			return this.starting.promise;
+		}
+		this.starting = Promise.withResolvers();
+		const now = Date.now();
+		this.log?.info("Starting App...");
+		for (const [key] of this.substitutions.entries()) this.inject(key);
+		const target = this.store.get("alepha.target");
+		if (target) {
+			this.registry = /* @__PURE__ */ new Map();
+			this.primitiveRegistry = /* @__PURE__ */ new Map();
+			this.with(target);
+		}
+		this.locked = true;
+		await this.events.emit("configure", this, { log: true });
+		this.configured = true;
+		await this.events.emit("start", this, { log: true });
+		this.started = true;
+		await this.events.emit("ready", this, { log: true });
+		this.log?.info(`App is now ready [${Date.now() - now}ms]`);
+		this.ready = true;
+		this.starting.resolve(this);
+		this.starting = void 0;
+		return this;
 	}
 	/**
-	* Create a schema for binary data represented as a base64 string.
+	* Stops the App.
+	*
+	* - Run "stop" hook for all services.
+	*
+	* Stop will NOT reset the container.
+	* Stop will NOT unlock the container.
+	*
+	* > Stop is used to gracefully shut down the application, nothing more. There is no "restart".
+	*
+	* @return A promise that resolves when the App has stopped.
 	*/
-	binary(options) {
-		return this.string({
-			...options,
-			format: "binary"
+	async stop() {
+		if (!this.started) return;
+		this.log?.info("Stopping App...");
+		await this.events.emit("stop", this, {
+			reverse: true,
+			log: true
 		});
+		this.log?.info("App is now off");
+		this.started = false;
+		this.ready = false;
 	}
 	/**
-	* Create a schema for uuid.
+	* Check if entry is registered in the container.
 	*/
-	uuid(options) {
-		return this.string({
-			...options,
-			format: "uuid"
-		});
+	has(entry, opts = {}) {
+		if (entry === Alepha) return true;
+		const { inStack = true, inRegistry = true, inSubstitutions = true, registry = this.registry } = opts;
+		const { provide } = typeof entry === "object" && "provide" in entry ? entry : { provide: entry };
+		if (inSubstitutions) {
+			if (this.substitutions.get(provide)) return true;
+		}
+		if (inRegistry) {
+			if (registry.get(provide)) return true;
+		}
+		if (inStack) {
+			const substitute = this.substitutions.get(provide)?.use;
+			if (substitute && this.pendingInstantiations.includes(substitute)) return true;
+			return this.pendingInstantiations.includes(provide);
+		}
+		return false;
 	}
 	/**
-	* Create a schema for a file-like object.
+	* Registers the specified service in the container.
 	*
-	* File like mimics the File API in browsers, but is adapted to work in Node.js as well.
+	* - If the service is ALREADY registered, the method does nothing.
+	* - If the service is NOT registered, a new instance is created and registered.
 	*
-	* Implementation of file-like objects is handled by "alepha/file" package.
+	* Method is chainable, so you can register multiple services in a single call.
+	*
+	* > ServiceEntry allows to provide a service **substitution** feature.
+	*
+	* @example
+	* ```ts
+	* class A { value = "a"; }
+	* class B { value = "b"; }
+	* class M { a = $inject(A); }
+	*
+	* Alepha.create().with({ provide: A, use: B }).get(M).a.value; // "b"
+	* ```
+	*
+	* > **Substitution** is an advanced feature that allows you to replace a service with another service.
+	* > It's useful for testing or for providing different implementations of a service.
+	* > If you are interested in configuring a service, use Alepha#configure() instead.
+	*
+	* @param serviceEntry - The service to register in the container.
+	* @return Current instance of Alepha.
 	*/
-	file(options) {
-		return Type.Unsafe(Type.Any({
-			[OPTIONS]: options,
-			format: "binary"
-		}));
+	with(serviceEntry) {
+		const entry = "default" in serviceEntry ? serviceEntry.default : serviceEntry;
+		if (this.has(entry, {
+			inSubstitutions: false,
+			inRegistry: false
+		})) return this;
+		if (typeof entry === "object") {
+			if (entry.provide === entry.use) {
+				this.inject(entry.provide);
+				return this;
+			}
+			if (!this.substitutions.has(entry.provide) && !this.has(entry.provide)) {
+				if (this.started) throw new ContainerLockedError();
+				if (MODULE in entry.provide && typeof entry.provide[MODULE] === "function") entry.use[MODULE] ??= entry.provide[MODULE];
+				this.substitutions.set(entry.provide, { use: entry.use });
+			} else if (!entry.optional) throw new TooLateSubstitutionError(entry.provide.name, entry.use.name);
+			return this;
+		}
+		this.inject(entry);
+		return this;
 	}
 	/**
-	* @experimental
+	* Get an instance of the specified service from the container.
+	*
+	* @see {@link InjectOptions} for the available options.
 	*/
-	stream() {
-		return Type.Unsafe(Type.Any({
-			format: "stream",
-			type: "string"
-		}));
-	}
-	email(options) {
-		return this.text({
-			...options,
-			format: "email",
-			trim: true,
-			lowercase: true
-		});
-	}
-	e164(options) {
-		return this.text({
-			...options,
-			description: "Phone number in E.164 format, e.g. +1234567890.",
-			pattern: "^\\+[1-9]\\d{1,14}$"
-		});
-	}
-	bcp47(options) {
-		return this.text({
-			...options,
-			description: "BCP 47 language tag, e.g. en, en-US, fr, fr-CA.",
-			pattern: "^[a-z]{2,3}(?:-[A-Z]{2})?$"
+	inject(service, opts = {}) {
+		const lifetime = opts.lifetime ?? "singleton";
+		const parent = opts.parent !== void 0 ? opts.parent : __alephaRef?.parent ?? Alepha;
+		const transient = lifetime === "transient";
+		const registry = lifetime === "scoped" ? this.context.get("registry") ?? this.registry : this.registry;
+		if (service === Alepha) return this;
+		if (typeof service === "string") {
+			for (const [key, value] of registry.entries()) if (key.name === service) return value.instance;
+			throw new AlephaError(`Service not found: ${service}`);
+		}
+		const substitute = this.substitutions.get(service);
+		if (substitute) return this.inject(substitute.use, {
+			parent,
+			lifetime
 		});
-	}
-	/**
-	* Create a schema for short text, such as names or titles.
-	* Default max length is 64 characters.
-	*/
-	shortText(options) {
-		return this.text({
-			size: "short",
-			...options
+		const index = this.pendingInstantiations.indexOf(service);
+		if (index !== -1 && !transient) throw new CircularDependencyError(service.name, this.pendingInstantiations.slice(0, index).map((it) => it.name));
+		if (!transient) {
+			const match = registry.get(service);
+			if (match) {
+				if (!match.parents.includes(parent) && parent !== service) match.parents.push(parent);
+				return match.instance;
+			}
+			if (this.started) throw new ContainerLockedError(`Container is locked. No more services can be added. ${parent?.name} -> ${service.name}`);
+		}
+		const module = service[MODULE];
+		if (module && typeof module === "function") this.with(module);
+		if (this.has(service, { registry }) && !transient) return this.inject(service, {
+			parent,
+			lifetime
 		});
+		const instance = this.new(service, opts.args);
+		const definition = {
+			parents: [parent],
+			instance
+		};
+		if (!transient) registry.set(service, definition);
+		if (instance instanceof Module) {
+			this.modules.push(instance);
+			const parent$1 = __alephaRef.parent;
+			__alephaRef.parent = instance.constructor;
+			instance.register(this);
+			__alephaRef.parent = parent$1;
+		}
+		return instance;
 	}
 	/**
-	* Create a schema for long text, such as descriptions or comments.
-	* Default max length is 1024 characters.
+	* Applies environment variables to the provided schema and state object.
+	*
+	* It replaces also all templated $ENV inside string values.
+	*
+	* @param schema - The schema object to apply environment variables to.
+	* @return The schema object with environment variables applied.
 	*/
-	longText(options) {
-		return this.text({
-			size: "long",
-			...options
-		});
+	parseEnv(schema) {
+		if (this.cacheEnv.has(schema)) return this.cacheEnv.get(schema);
+		const config = this.codec.validate(schema, this.env);
+		for (const key in config) if (typeof config[key] === "string") for (const env in config) config[key] = config[key].replace(new RegExp(`\\$${env}`, "gim"), config[env]);
+		this.cacheEnv.set(schema, config);
+		return config;
 	}
 	/**
-	* Create a schema for rich text, such as HTML or Markdown.
-	* Default max length is 65535 characters.
+	* Get all environment variable schemas and their parsed values.
+	*
+	* This is useful for DevTools to display all expected environment variables.
 	*/
-	richText(options) {
-		return this.text({
-			size: "rich",
-			...options
+	getEnvSchemas() {
+		const result = [];
+		for (const [schema, values] of this.cacheEnv.entries()) result.push({
+			schema,
+			values
 		});
+		return result;
 	}
 	/**
-	* Create a schema for a string enum e.g. LIKE_THIS.
+	* Dump the current dependency graph of the App.
+	*
+	* This method returns a record where the keys are the names of the services.
 	*/
-	snakeCase = (options) => this.text({
-		pattern: "^[A-Z_-]+$",
-		...options
-	});
+	graph() {
+		for (const [key] of this.substitutions.entries()) if (!this.has(key)) this.inject(key);
+		const graph = {};
+		for (const [provide, { parents }] of this.registry.entries()) {
+			graph[provide.name] = { from: parents.filter((it) => !!it).map((it) => it.name) };
+			const aliases = this.substitutions.entries().filter((it) => it[1].use === provide).map((it) => it[0].name).toArray();
+			if (aliases.length) graph[provide.name].as = aliases;
+			const module = Module.of(provide);
+			if (module) graph[provide.name].module = module.name;
+		}
+		return graph;
+	}
+	services(base) {
+		const list = [];
+		for (const [key, value] of this.registry.entries()) if (value.instance instanceof base) list.push(value.instance);
+		return list;
+	}
 	/**
-	* Create a schema for an object with a value and label.
+	* Get all primitives of the specified type.
 	*/
-	valueLabel = (options) => this.object({
-		value: this.snakeCase({ description: "Machine-readable value." }),
-		label: this.text({ description: "Human-readable label." }),
-		description: this.optional(this.text({
-			description: "Description of the value.",
-			size: "long"
-		}))
-	}, options);
-	datetime = (options) => t.text({
-		...options,
-		format: "date-time"
-	});
-	date = (options) => t.text({
-		...options,
-		format: "date"
-	});
-	time = (options) => t.text({
-		...options,
-		format: "time"
-	});
-	duration = (options) => t.text({
-		...options,
-		format: "duration"
-	});
+	primitives(factory) {
+		if (typeof factory === "string") {
+			const key1 = factory.toLowerCase().replace("$", "");
+			const key2 = `${key1}primitive`;
+			for (const [key, value] of this.primitiveRegistry.entries()) {
+				const name = key.name.toLowerCase();
+				if (name === key1 || name === key2) return value;
+			}
+			return [];
+		}
+		return this.primitiveRegistry.get(factory[KIND]) ?? [];
+	}
+	new(service, args = []) {
+		this.pendingInstantiations.push(service);
+		__alephaRef.alepha = this;
+		__alephaRef.service = service;
+		const instance = isClass(service) ? new service(...args) : service(...args) ?? {};
+		const obj = instance;
+		for (const [key, value] of Object.entries(obj)) {
+			if (value instanceof Primitive) this.processPrimitive(value, key);
+			if (typeof value === "object" && value !== null && typeof value[OPTIONS] === "object" && "getter" in value[OPTIONS]) {
+				const getter = value[OPTIONS].getter;
+				Object.defineProperty(obj, key, { get: () => this.store.get(getter) });
+			}
+		}
+		this.pendingInstantiations.pop();
+		if (this.pendingInstantiations.length === 0) __alephaRef.alepha = void 0;
+		__alephaRef.service = this.pendingInstantiations[this.pendingInstantiations.length - 1];
+		return instance;
+	}
+	processPrimitive(value, propertyKey = "") {
+		value.config.propertyKey = propertyKey;
+		value.onInit();
+		const kind = value.constructor;
+		const list = this.primitiveRegistry.get(kind) ?? [];
+		this.primitiveRegistry.set(kind, [...list, value]);
+	}
+};
+
+//#endregion
+//#region ../../src/core/errors/AppNotStartedError.ts
+var AppNotStartedError = class extends AlephaError {
+	name = "AppNotStartedError";
+	constructor() {
+		super("App not started. Please start the app before.");
+	}
 };
-const t = new TypeProvider();
+
+//#endregion
+//#region ../../src/core/helpers/createPagination.ts
+/**
+* Create a pagination object from an array of entities.
+*
+* This is a pure function that works with any data source (databases, APIs, caches, arrays, etc.).
+* It handles the core pagination logic including:
+* - Slicing the content to the requested page size
+* - Calculating pagination metadata (offset, page number, etc.)
+* - Determining navigation state (isFirst, isLast)
+* - Including sort metadata when provided
+*
+* @param entities - The entities to paginate (should include one extra item to detect if there's a next page)
+* @param limit - The limit of the pagination (page size)
+* @param offset - The offset of the pagination (starting position)
+* @param sort - Optional sort metadata to include in response
+* @returns A complete Page object with content and metadata
+*
+* @example Basic pagination
+* ```ts
+* const users = await fetchUsers({ limit: 11, offset: 0 }); // Fetch limit + 1
+* const page = createPagination(users, 10, 0);
+* // page.content has max 10 items
+* // page.page.isLast tells us if there are more pages
+* ```
+*
+* @example With sorting
+* ```ts
+* const page = createPagination(
+*   entities,
+*   10,
+*   0,
+*   [{ column: "name", direction: "asc" }]
+* );
+* ```
+*
+* @example In a custom service
+* ```ts
+* class MyService {
+*   async listItems(page: number, size: number) {
+*     const items = await this.fetchItems({ limit: size + 1, offset: page * size });
+*     return createPagination(items, size, page * size);
+*   }
+* }
+* ```
+*/
+function createPagination(entities, limit = 10, offset = 0, sort) {
+	const content = entities.slice(0, limit);
+	const hasNext = entities.length === limit + 1;
+	const pageNumber = Math.floor(offset / limit);
+	return {
+		content,
+		page: {
+			number: pageNumber,
+			size: limit,
+			offset,
+			numberOfElements: content.length,
+			isEmpty: content.length === 0,
+			isFirst: pageNumber === 0,
+			isLast: !hasNext,
+			...sort && sort.length > 0 ? { sort: {
+				sorted: true,
+				fields: sort.map((s) => ({
+					field: s.column,
+					direction: s.direction
+				}))
+			} } : {}
+		}
+	};
+}
 
 //#endregion
 //#region ../../src/core/helpers/jsonSchemaToTypeBox.ts
@@ -2116,63 +2189,6 @@ const $env = (type) => {
 	return alepha.parseEnv(type);
 };
 
-//#endregion
-//#region ../../src/core/primitives/$hook.ts
-/**
-* Registers a new hook.
-*
-* ```ts
-* import { $hook } from "alepha";
-*
-* class MyProvider {
-*   onStart = $hook({
-*     name: "start", // or "configure", "ready", "stop", ...
-*     handler: async (app) => {
-*       // await db.connect(); ...
-*     }
-*   });
-* }
-* ```
-*
-* Hooks are used to run async functions from all registered providers/services.
-*
-* You can't register a hook after the App has started.
-*
-* It's used under the hood by the `configure`, `start`, and `stop` methods.
-* Some modules also use hooks to run their own logic. (e.g. `alepha/server`).
-*
-* You can create your own hooks by using module augmentation:
-*
-* ```ts
-* declare module "alepha" {
-*
-*   interface Hooks {
-*     "my:custom:hook": {
-*       arg1: string;
-*     }
-*   }
-* }
-*
-* await alepha.events.emit("my:custom:hook", { arg1: "value" });
-* ```
-*
-*/
-const $hook = (options) => createPrimitive(HookPrimitive, options);
-var HookPrimitive = class extends Primitive {
-	called = 0;
-	onInit() {
-		this.alepha.events.on(this.options.on, {
-			caller: this.config.service,
-			priority: this.options.priority,
-			callback: async (args) => {
-				this.called += 1;
-				await this.options.handler(args);
-			}
-		});
-	}
-};
-$hook[KIND] = HookPrimitive;
-
 //#endregion
 //#region ../../src/core/primitives/$use.ts
 /**