alepha 0.13.0 → 0.13.2

package/dist/core/{index.cjs → index.native.js}

@@ -1,46 +1,13 @@
-//#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") {
-		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-			key = keys[i];
-			if (!__hasOwnProp.call(to, key) && key !== except) {
-				__defProp(to, key, {
-					get: ((k) => from[k]).bind(null, key),
-					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-				});
-			}
-		}
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
-let node_async_hooks = require("node:async_hooks");
-let node_cluster = require("node:cluster");
-node_cluster = __toESM(node_cluster);
-let node_os = require("node:os");
-let typebox_compile = require("typebox/compile");
-let typebox = require("typebox");
-typebox = __toESM(typebox);
-let typebox_format = require("typebox/format");
-typebox_format = __toESM(typebox_format);
-let typebox_system = require("typebox/system");
-let typebox_value = require("typebox/value");
-typebox_value = __toESM(typebox_value);
+import { Compile } from "typebox/compile";
+import * as TypeBox from "typebox";
+import { Type } from "typebox";
+import TypeBoxFormat from "typebox/format";
+import { Locale } from "typebox/system";
+import * as TypeBoxValue from "typebox/value";
 
 //#region src/core/constants/KIND.ts
 /**
-* Used for identifying descriptors.
+* Used for identifying primitives.
 *
 * @internal
 */
@@ -58,7 +25,7 @@ const MODULE = Symbol.for("Alepha.Module");
 //#endregion
 //#region src/core/constants/OPTIONS.ts
 /**
-* Used for descriptors options.
+* Used for primitives options.
 *
 * @internal
 */
@@ -73,98 +40,6 @@ var AlephaError = class extends Error {
 	name = "AlephaError";
 };
 
-//#endregion
-//#region src/core/descriptors/$module.ts
-/**
-* Wrap Services and Descriptors into a Module.
-*
-* - A module is just a Service with some extra {@link Module}.
-* - You must attach a `name` to it.
-* - Name must follow the pattern: `project.module.submodule`. (e.g. `myapp.users.auth`).
-*
-* @example
-* ```ts
-* import { $module } from "alepha";
-* import { MyService } from "./MyService.ts";
-*
-* // export MyService, so it can be used everywhere (optional)
-* export * from "./MyService.ts";
-*
-* export default $module({
-*  name: "my.project.module",
-*  // MyService will have a module context "my.project.module"
-*  services: [MyService],
-* });
-* ```
-*
-* ### Why Modules?
-*
-* #### Logging
-*
-* By default, AlephaLogger will log the module name in the logs.
-* This helps to identify where the logs are coming from.
-*
-* You can also set different log levels for different modules.
-* It means you can set 'some.very.specific.module' to 'debug' and keep the rest of the application to 'info'.
-*
-* #### Modulith
-*
-* Force to structure your application in modules, even if it's a single deployable unit.
-* It helps to keep a clean architecture and avoid monolithic applications.
-*
-* A strict mode flag will probably come to enforce module boundaries.
-* -> Throwing errors when a service from another module is injected.
-* But it's not implemented yet.
-*
-* ### When not to use Modules?
-*
-* Small applications does not need modules. It's better to keep it simple.
-* Modules are more useful when the application grows and needs to be structured.
-* If we speak with number of `$actions`, a module should be used when you have more than 30 actions in a single module.
-* Meaning that if you have 100 actions, you should have at least 3 modules.
-*/
-const $module = (options) => {
-	const { services = [], descriptors = [], name } = options;
-	if (!name || !Module.NAME_REGEX.test(name)) throw new AlephaError(`Invalid module name '${name}'. It should be in the format of 'project.module.submodule'`);
-	const $ = class extends Module {
-		options = options;
-		register(alepha) {
-			if (typeof options.register === "function") {
-				options.register(alepha);
-				return;
-			}
-			for (const service of services) alepha.inject(service, { parent: this.constructor });
-		}
-	};
-	Object.defineProperty($, "name", {
-		value: name,
-		writable: false
-	});
-	for (const service of services) if (!Module.is(service)) service[MODULE] = $;
-	for (const factory of descriptors) if (typeof factory[KIND] === "function") factory[KIND][MODULE] = $;
-	return $;
-};
-/**
-* Base class for all modules.
-*/
-var Module = class Module {
-	static NAME_REGEX = /^[a-z]+(\.[a-z][a-z0-9-]*)*$/;
-	/**
-	* Check if a Service is a Module.
-	*/
-	static is(ctor) {
-		return ctor.prototype instanceof Module;
-	}
-	/**
-	* Get the Module of a Service.
-	*
-	* Returns undefined if the Service is not part of a Module.
-	*/
-	static of(ctor) {
-		return ctor[MODULE];
-	}
-};
-
 //#endregion
 //#region src/core/errors/CircularDependencyError.ts
 var CircularDependencyError = class extends AlephaError {
@@ -213,7 +88,7 @@ const __alephaRef = {};
 /**
 * Note:
 *
-* This file is used to share context between $descriptors and the Alepha core during the injection phase.
+* This file is used to share context between $primitives and the Alepha core during the injection phase.
 *
 * There is no side effect as long as Alepha is not used concurrently in multiple contexts (which is not the case).
 *
@@ -252,11 +127,11 @@ const __alephaRef = {};
 */
 
 //#endregion
-//#region src/core/descriptors/$context.ts
+//#region src/core/primitives/$context.ts
 /**
 * Get Alepha instance and current service from the current context.
 *
-* It can only be used inside $descriptor functions.
+* It can only be used inside $primitive functions.
 *
 * ```ts
 * import { $context } from "alepha";
@@ -265,7 +140,7 @@ const __alephaRef = {};
 *   const { alepha, service, module } = $context();
 *
 *   // alepha - alepha instance
-*   // service - class which is creating this descriptor, this is NOT the instance but the service definition
+*   // service - class which is creating this primitive, this is NOT the instance but the service definition
 *   // module - module definition, if any
 *
 *   return {};
@@ -290,8 +165,8 @@ const $context = () => {
 };
 
 //#endregion
-//#region src/core/helpers/descriptor.ts
-var Descriptor = class {
+//#region src/core/helpers/primitive.ts
+var Primitive = class {
 	alepha;
 	options;
 	config;
@@ -305,14 +180,14 @@ var Descriptor = class {
 		};
 	}
 	/**
-	* Called automatically by Alepha after the descriptor is created.
+	* Called automatically by Alepha after the primitive is created.
 	*/
 	onInit() {}
 };
-const createDescriptor = (descriptor, options) => {
+const createPrimitive = (primitive, options) => {
 	const { alepha, service } = $context();
-	if (MODULE in descriptor && descriptor[MODULE]) alepha.with(descriptor[MODULE]);
-	return alepha.inject(descriptor, {
+	if (MODULE in primitive && primitive[MODULE]) alepha.with(primitive[MODULE]);
+	return alepha.inject(primitive, {
 		lifetime: "transient",
 		args: [{
 			options,
@@ -330,6 +205,98 @@ function isClass(func) {
 	return !!descriptor && !descriptor.writable;
 }
 
+//#endregion
+//#region src/core/primitives/$module.ts
+/**
+* Wrap Services and Primitives into a Module.
+*
+* - A module is just a Service with some extra {@link Module}.
+* - You must attach a `name` to it.
+* - Name must follow the pattern: `project.module.submodule`. (e.g. `myapp.users.auth`).
+*
+* @example
+* ```ts
+* import { $module } from "alepha";
+* import { MyService } from "./MyService.ts";
+*
+* // export MyService, so it can be used everywhere (optional)
+* export * from "./MyService.ts";
+*
+* export default $module({
+*  name: "my.project.module",
+*  // MyService will have a module context "my.project.module"
+*  services: [MyService],
+* });
+* ```
+*
+* ### Why Modules?
+*
+* #### Logging
+*
+* By default, AlephaLogger will log the module name in the logs.
+* This helps to identify where the logs are coming from.
+*
+* You can also set different log levels for different modules.
+* It means you can set 'some.very.specific.module' to 'debug' and keep the rest of the application to 'info'.
+*
+* #### Modulith
+*
+* Force to structure your application in modules, even if it's a single deployable unit.
+* It helps to keep a clean architecture and avoid monolithic applications.
+*
+* A strict mode flag will probably come to enforce module boundaries.
+* -> Throwing errors when a service from another module is injected.
+* But it's not implemented yet.
+*
+* ### When not to use Modules?
+*
+* Small applications does not need modules. It's better to keep it simple.
+* Modules are more useful when the application grows and needs to be structured.
+* If we speak with number of `$actions`, a module should be used when you have more than 30 actions in a single module.
+* Meaning that if you have 100 actions, you should have at least 3 modules.
+*/
+const $module = (options) => {
+	const { services = [], primitives = [], name } = options;
+	if (!name || !Module.NAME_REGEX.test(name)) throw new AlephaError(`Invalid module name '${name}'. It should be in the format of 'project.module.submodule'`);
+	const $ = class extends Module {
+		options = options;
+		register(alepha) {
+			if (typeof options.register === "function") {
+				options.register(alepha);
+				return;
+			}
+			for (const service of services) alepha.inject(service, { parent: this.constructor });
+		}
+	};
+	Object.defineProperty($, "name", {
+		value: name,
+		writable: false
+	});
+	for (const service of services) if (!Module.is(service)) service[MODULE] = $;
+	for (const factory of primitives) if (typeof factory[KIND] === "function") factory[KIND][MODULE] = $;
+	return $;
+};
+/**
+* Base class for all modules.
+*/
+var Module = class Module {
+	static NAME_REGEX = /^[a-z]+(\.[a-z][a-z0-9-]*)*$/;
+	/**
+	* Check if a Service is a Module.
+	*/
+	static is(ctor) {
+		return ctor.prototype instanceof Module;
+	}
+	/**
+	* Get the Module of a Service.
+	*
+	* Returns undefined if the Service is not part of a Module.
+	*/
+	static of(ctor) {
+		return ctor[MODULE];
+	}
+};
+
 //#endregion
 //#region src/core/providers/AlsProvider.ts
 var AlsProvider = class AlsProvider {
@@ -363,7 +330,7 @@ var AlsProvider = class AlsProvider {
 };
 
 //#endregion
-//#region src/core/descriptors/$inject.ts
+//#region src/core/primitives/$inject.ts
 /**
 * Get the instance of the specified type from the context.
 *
@@ -382,7 +349,7 @@ const $inject = (type, opts = {}) => {
 		...opts
 	});
 };
-var InjectDescriptor = class extends Descriptor {};
+var InjectPrimitive = class extends Primitive {};
 
 //#endregion
 //#region src/core/providers/Json.ts
@@ -475,7 +442,7 @@ var SchemaValidator = class {
 	}
 	getValidator(schema) {
 		if (this.cache.has(schema)) return this.cache.get(schema);
-		const validator = (0, typebox_compile.Compile)(schema);
+		const validator = Compile(schema);
 		this.cache.set(schema, validator);
 		return validator;
 	}
@@ -650,7 +617,7 @@ var EventManager = class {
 };
 
 //#endregion
-//#region src/core/descriptors/$atom.ts
+//#region src/core/primitives/$atom.ts
 /**
 * Define an atom for state management.
 *
@@ -853,7 +820,7 @@ var StateManager = class {
 * // You can access the environment variables using alepha.env
 * console.log(alepha.env.MY_VAR); // "value"
 *
-* // But you should use $env() descriptor to get typed values from the environment.
+* // But you should use $env() primitive to get typed values from the environment.
 * class App {
 *   env = $env(
 *     t.object({
@@ -866,7 +833,7 @@ var StateManager = class {
 * ### Modules
 *
 * Modules are a way to group services together.
-* You can register a module using the `$module` descriptor.
+* You can register a module using the `$module` primitive.
 *
 * ```ts
 * import { $module } from "alepha";
@@ -884,7 +851,7 @@ var StateManager = class {
 * ### Hooks
 *
 * Hooks are a way to run async functions from all registered providers/services.
-* You can register a hook using the `$hook` descriptor.
+* You can register a hook using the `$hook` primitive.
 *
 * ```ts
 * import { $hook } from "alepha";
@@ -945,7 +912,7 @@ var Alepha = class Alepha {
 			try {
 				onTestFinished?.(() => alepha.stop());
 			} catch (_error) {}
-			alepha.state.set("alepha.test.beforeAll", beforeAll).set("alepha.test.afterAll", afterAll).set("alepha.test.afterEach", afterEach).set("alepha.test.onTestFinished", onTestFinished);
+			alepha.store.set("alepha.test.beforeAll", beforeAll).set("alepha.test.afterAll", afterAll).set("alepha.test.afterEach", afterEach).set("alepha.test.onTestFinished", onTestFinished);
 		}
 		return alepha;
 	}
@@ -999,9 +966,9 @@ var Alepha = class Alepha {
 	*/
 	substitutions = /* @__PURE__ */ new Map();
 	/**
-	* Registry of descriptors.
+	* Registry of primitives.
 	*/
-	descriptorRegistry = /* @__PURE__ */ new Map();
+	primitiveRegistry = /* @__PURE__ */ new Map();
 	/**
 	*  List of all services + how they are provided.
 	*/
@@ -1025,7 +992,7 @@ var Alepha = class Alepha {
 	/**
 	* State manager to store arbitrary values.
 	*/
-	get state() {
+	get store() {
 		this.events;
 		return this.inject(StateManager, { args: [this.init] });
 	}
@@ -1041,13 +1008,13 @@ var Alepha = class Alepha {
 	* Get logger instance.
 	*/
 	get log() {
-		return this.state.get("alepha.logger");
+		return this.store.get("alepha.logger");
 	}
 	/**
 	* The environment variables for the App.
 	*/
 	get env() {
-		return this.state.get("env") ?? {};
+		return this.store.get("env") ?? {};
 	}
 	constructor(init = {}) {
 		this.init = init;
@@ -1136,7 +1103,7 @@ var Alepha = class Alepha {
 	* Starts the App.
 	*
 	* - Lock any further changes to the container.
-	* - Run "configure" hook for all services. Descriptors will be processed.
+	* - 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.
 	*
@@ -1156,10 +1123,10 @@ var Alepha = class Alepha {
 		const now = Date.now();
 		this.log?.info("Starting App...");
 		for (const [key] of this.substitutions.entries()) this.inject(key);
-		const target = this.state.get("alepha.target");
+		const target = this.store.get("alepha.target");
 		if (target) {
 			this.registry = /* @__PURE__ */ new Map();
-			this.descriptorRegistry = /* @__PURE__ */ new Map();
+			this.primitiveRegistry = /* @__PURE__ */ new Map();
 			this.with(target);
 		}
 		this.locked = true;
@@ -1294,8 +1261,8 @@ var Alepha = class Alepha {
 			}
 			if (this.started) throw new ContainerLockedError(`Container is locked. No more services can be added. ${parent?.name} -> ${service.name}`);
 		}
-		const module$1 = service[MODULE];
-		if (module$1 && typeof module$1 === "function") this.with(module$1);
+		const module = service[MODULE];
+		if (module && typeof module === "function") this.with(module);
 		if (this.has(service, { registry }) && !transient) return this.inject(service, {
 			parent,
 			lifetime
@@ -1342,8 +1309,8 @@ var Alepha = class Alepha {
 			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$1 = Module.of(provide);
-			if (module$1) graph[provide.name].module = module$1.name;
+			const module = Module.of(provide);
+			if (module) graph[provide.name].module = module.name;
 		}
 		return graph;
 	}
@@ -1353,19 +1320,19 @@ var Alepha = class Alepha {
 		return list;
 	}
 	/**
-	* Get all descriptors of the specified type.
+	* Get all primitives of the specified type.
 	*/
-	descriptors(factory) {
+	primitives(factory) {
 		if (typeof factory === "string") {
 			const key1 = factory.toLowerCase().replace("$", "");
-			const key2 = `${key1}descriptor`;
-			for (const [key, value] of this.descriptorRegistry.entries()) {
+			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.descriptorRegistry.get(factory[KIND]) ?? [];
+		return this.primitiveRegistry.get(factory[KIND]) ?? [];
 	}
 	new(service, args = []) {
 		this.pendingInstantiations.push(service);
@@ -1374,10 +1341,10 @@ var Alepha = class Alepha {
 		const instance = isClass(service) ? new service(...args) : service(...args) ?? {};
 		const obj = instance;
 		for (const [key, value] of Object.entries(obj)) {
-			if (value instanceof Descriptor) this.processDescriptor(value, key);
+			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.state.get(getter) });
+				Object.defineProperty(obj, key, { get: () => this.store.get(getter) });
 			}
 		}
 		this.pendingInstantiations.pop();
@@ -1385,15 +1352,95 @@ var Alepha = class Alepha {
 		__alephaRef.service = this.pendingInstantiations[this.pendingInstantiations.length - 1];
 		return instance;
 	}
-	processDescriptor(value, propertyKey = "") {
+	processPrimitive(value, propertyKey = "") {
 		value.config.propertyKey = propertyKey;
 		value.onInit();
 		const kind = value.constructor;
-		const list = this.descriptorRegistry.get(kind) ?? [];
-		this.descriptorRegistry.set(kind, [...list, value]);
+		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.");
+	}
+};
+
+//#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/FileLike.ts
 const isTypeFile = (value) => {
@@ -1405,33 +1452,33 @@ const isFileLike = (value) => {
 
 //#endregion
 //#region src/core/providers/TypeProvider.ts
-const isUUID = typebox_format.default.IsUuid;
-const isEmail = typebox_format.default.IsEmail;
-const isURL = typebox_format.default.IsUrl;
-const isDateTime = typebox_format.default.IsDateTime;
-const isDate = typebox_format.default.IsDate;
-const isTime = typebox_format.default.IsTime;
-const isDuration = typebox_format.default.IsDuration;
+const isUUID = TypeBoxFormat.IsUuid;
+const isEmail = TypeBoxFormat.IsEmail;
+const isURL = TypeBoxFormat.IsUrl;
+const isDateTime = TypeBoxFormat.IsDateTime;
+const isDate = TypeBoxFormat.IsDate;
+const isTime = TypeBoxFormat.IsTime;
+const isDuration = TypeBoxFormat.IsDuration;
 var TypeGuard = class {
-	isBigInt = (value) => typebox.IsString(value) && "format" in value && value.format === "bigint";
-	isUUID = (value) => typebox.IsString(value) && "format" in value && value.format === "uuid";
-	isObject = typebox.IsObject;
-	isNumber = typebox.IsNumber;
-	isString = typebox.IsString;
-	isBoolean = typebox.IsBoolean;
-	isAny = typebox.IsAny;
-	isArray = typebox.IsArray;
-	isOptional = typebox.IsOptional;
-	isUnion = typebox.IsUnion;
-	isInteger = typebox.IsInteger;
-	isNull = typebox.IsNull;
-	isUndefined = typebox.IsUndefined;
-	isUnsafe = typebox.IsUnsafe;
-	isRecord = typebox.IsRecord;
-	isTuple = typebox.IsTuple;
-	isVoid = typebox.IsVoid;
-	isLiteral = typebox.IsLiteral;
-	isSchema = typebox.IsSchema;
+	isBigInt = (value) => TypeBox.IsString(value) && "format" in value && value.format === "bigint";
+	isUUID = (value) => TypeBox.IsString(value) && "format" in value && value.format === "uuid";
+	isObject = TypeBox.IsObject;
+	isNumber = TypeBox.IsNumber;
+	isString = TypeBox.IsString;
+	isBoolean = TypeBox.IsBoolean;
+	isAny = TypeBox.IsAny;
+	isArray = TypeBox.IsArray;
+	isOptional = TypeBox.IsOptional;
+	isUnion = TypeBox.IsUnion;
+	isInteger = TypeBox.IsInteger;
+	isNull = TypeBox.IsNull;
+	isUndefined = TypeBox.IsUndefined;
+	isUnsafe = TypeBox.IsUnsafe;
+	isRecord = TypeBox.IsRecord;
+	isTuple = TypeBox.IsTuple;
+	isVoid = TypeBox.IsVoid;
+	isLiteral = TypeBox.IsLiteral;
+	isSchema = TypeBox.IsSchema;
 	isFile = isTypeFile;
 	isDateTime = (schema) => {
 		return t.schema.isString(schema) && schema.format === "date-time";
@@ -1447,23 +1494,23 @@ var TypeGuard = class {
 	};
 };
 var TypeProvider = class TypeProvider {
-	static format = typebox_format.default;
+	static format = TypeBoxFormat;
 	static {
-		typebox_format.default.Set("bigint", (value) => TypeProvider.isValidBigInt(value));
+		TypeBoxFormat.Set("bigint", (value) => TypeProvider.isValidBigInt(value));
 	}
 	static translateError(error, locale) {
 		if (!locale) return error.cause.message;
-		for (const [key, value] of Object.entries(typebox_system.Locale)) {
+		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(typebox_system.Locale)) {
+		for (const [key, value] of Object.entries(Locale)) {
 			if (key === "Set" || key === "Get" || key === "Reset") continue;
 			if (key === locale || key.startsWith(`${locale}_`)) {
-				typebox_system.Locale.Set(value);
+				Locale.Set(value);
 				return;
 			}
 		}
@@ -1523,16 +1570,16 @@ var TypeProvider = class TypeProvider {
 	* It can be overridden in the array options.
 	*/
 	static DEFAULT_ARRAY_MAX_ITEMS = 1e3;
-	raw = typebox.Type;
-	any = typebox.Type.Any;
-	void = typebox.Type.Void;
-	undefined = typebox.Type.Undefined;
-	record = typebox.Type.Record;
-	union = typebox.Type.Union;
-	tuple = typebox.Type.Tuple;
-	null = typebox.Type.Null;
-	const = typebox.Type.Literal;
-	options = typebox.Type.Options;
+	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.
@@ -1546,25 +1593,25 @@ var TypeProvider = class TypeProvider {
 	*/
 	schema = new TypeGuard();
 	extend(schema, properties, options) {
-		return typebox.Type.Interface(Array.isArray(schema) ? schema : [schema], properties, {
+		return Type.Interface(Array.isArray(schema) ? schema : [schema], properties, {
 			additionalProperties: false,
 			...options
 		});
 	}
 	pick(schema, keys, options) {
-		return typebox.Type.Pick(schema, keys, {
+		return Type.Pick(schema, keys, {
 			additionalProperties: false,
 			...options
 		});
 	}
 	omit(schema, keys, options) {
-		return typebox.Type.Omit(schema, keys, {
+		return Type.Omit(schema, keys, {
 			additionalProperties: false,
 			...options
 		});
 	}
 	partial(schema, options) {
-		return typebox.Type.Partial(schema, {
+		return Type.Partial(schema, {
 			additionalProperties: false,
 			...options
 		});
@@ -1582,7 +1629,7 @@ var TypeProvider = class TypeProvider {
 	* ```
 	*/
 	object(properties, options) {
-		return typebox.Type.Object(properties, {
+		return Type.Object(properties, {
 			additionalProperties: false,
 			...options
 		});
@@ -1594,7 +1641,7 @@ var TypeProvider = class TypeProvider {
 	* @see TypeProvider.DEFAULT_ARRAY_MAX_ITEMS
 	*/
 	array(schema, options) {
-		return typebox.Type.Array(schema, {
+		return Type.Array(schema, {
 			maxItems: TypeProvider.DEFAULT_ARRAY_MAX_ITEMS,
 			...options
 		});
@@ -1606,7 +1653,7 @@ var TypeProvider = class TypeProvider {
 	* 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 typebox.Type.String({ ...options });
+		return Type.String({ ...options });
 	}
 	/**
 	* Create a schema for a string with length limits.
@@ -1617,7 +1664,7 @@ var TypeProvider = class TypeProvider {
 	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 typebox.Type.String({
+		return Type.String({
 			maxLength,
 			"~options": {
 				trim: options.trim ?? true,
@@ -1637,22 +1684,22 @@ var TypeProvider = class TypeProvider {
 	* Create a schema for a boolean.
 	*/
 	boolean(options) {
-		return typebox.Type.Boolean({ ...options });
+		return Type.Boolean({ ...options });
 	}
 	/**
 	* Create a schema for a number.
 	*/
 	number(options) {
-		return typebox.Type.Number({ ...options });
+		return Type.Number({ ...options });
 	}
 	/**
 	* Create a schema for an integer.
 	*/
 	integer(options) {
-		return typebox.Type.Integer({ ...options });
+		return Type.Integer({ ...options });
 	}
 	int32(options) {
-		return typebox.Type.Integer({
+		return Type.Integer({
 			minimum: -2147483647,
 			maximum: 2147483647,
 			...options
@@ -1666,7 +1713,7 @@ var TypeProvider = class TypeProvider {
 	* Use `t.bigint()` for true int64 values represented as strings.
 	*/
 	int64(options) {
-		return typebox.Type.Number({
+		return Type.Number({
 			format: "int64",
 			multipleOf: 1,
 			minimum: -9007199254740991,
@@ -1678,23 +1725,23 @@ var TypeProvider = class TypeProvider {
 	* Make a schema optional.
 	*/
 	optional(schema) {
-		return typebox.Type.Optional(schema);
+		return Type.Optional(schema);
 	}
 	/**
 	* Make a schema nullable.
 	*/
 	nullable(schema, options) {
-		return typebox.Type.Union([typebox.Type.Null(), schema], options);
+		return Type.Union([Type.Null(), schema], options);
 	}
 	/**
 	* Create a schema that maps all properties of an object schema to nullable.
 	*/
-	nullify = (schema, options) => typebox.Type.Mapped(typebox.Type.Identifier("K"), typebox.Type.KeyOf(schema), typebox.Type.Ref("K"), typebox.Type.Union([typebox.Type.Index(schema, typebox.Type.Ref("K")), typebox.Type.Null()]), options);
+	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 typebox.Type.Unsafe(t.text({
+		return Type.Unsafe(t.text({
 			enum: values,
 			pattern: values.map((v) => `^${v}$`).join("|"),
 			...options
@@ -1745,7 +1792,7 @@ var TypeProvider = class TypeProvider {
 	* Implementation of file-like objects is handled by "alepha/file" package.
 	*/
 	file(options) {
-		return typebox.Type.Unsafe(typebox.Type.Any({
+		return Type.Unsafe(Type.Any({
 			[OPTIONS]: options,
 			format: "binary"
 		}));
@@ -1754,7 +1801,7 @@ var TypeProvider = class TypeProvider {
 	* @experimental
 	*/
 	stream() {
-		return typebox.Type.Unsafe(typebox.Type.Any({
+		return Type.Unsafe(Type.Any({
 			format: "stream",
 			type: "string"
 		}));
@@ -1849,7 +1896,7 @@ var TypeProvider = class TypeProvider {
 const t = new TypeProvider();
 
 //#endregion
-//#region src/core/descriptors/$env.ts
+//#region src/core/primitives/$env.ts
 /**
 * Get typed values from environment variables.
 *
@@ -1883,7 +1930,7 @@ const $env = (type) => {
 };
 
 //#endregion
-//#region src/core/descriptors/$hook.ts
+//#region src/core/primitives/$hook.ts
 /**
 * Registers a new hook.
 *
@@ -1923,8 +1970,8 @@ const $env = (type) => {
 * ```
 *
 */
-const $hook = (options) => createDescriptor(HookDescriptor, options);
-var HookDescriptor = class extends Descriptor {
+const $hook = (options) => createPrimitive(HookPrimitive, options);
+var HookPrimitive = class extends Primitive {
 	called = 0;
 	onInit() {
 		this.alepha.events.on(this.options.on, {
@@ -1937,10 +1984,10 @@ var HookDescriptor = class extends Descriptor {
 		});
 	}
 };
-$hook[KIND] = HookDescriptor;
+$hook[KIND] = HookPrimitive;
 
 //#endregion
-//#region src/core/descriptors/$use.ts
+//#region src/core/primitives/$use.ts
 /**
 * Subscribes to an atom's state and returns its current value for use in components.
 *
@@ -1965,94 +2012,14 @@ $hook[KIND] = HookDescriptor;
 */
 const $use = (atom) => {
 	const { alepha } = $context();
-	alepha.state.register(atom);
-	const init = alepha.state.get(atom.key);
+	alepha.store.register(atom);
+	const init = alepha.store.get(atom.key);
 	return {
 		[OPTIONS]: { getter: atom.key },
 		...init
 	};
 };
 
-//#endregion
-//#region src/core/errors/AppNotStartedError.ts
-var AppNotStartedError = class extends AlephaError {
-	name = "AppNotStartedError";
-	constructor() {
-		super("App not started. Please start the app before.");
-	}
-};
-
-//#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/schemas/pageQuerySchema.ts
 const pageQuerySchema = t.object({
@@ -2119,146 +2086,28 @@ const pageSchema = (objectSchema, options) => t.object({
 TypeProvider.prototype.page = (itemSchema) => pageSchema(itemSchema);
 
 //#endregion
-//#region src/core/index.ts
-/**
-* Run Alepha application, trigger start lifecycle.
-*
-* ```ts
-* import { Alepha, run } from "alepha";
-* import { MyService } from "./services/MyService.ts";
-*
-* const alepha = new Alepha({ env: { APP_NAME: "MyAlephaApp" } });
-*
-* alepha.with(MyService);
-*
-* export default run(alepha);
-* ```
-*/
+//#region src/core/index.native.ts
+if (!Promise.withResolvers) Promise.withResolvers = () => {
+	let resolve;
+	let reject;
+	return {
+		promise: new Promise((res, rej) => {
+			resolve = res;
+			reject = rej;
+		}),
+		resolve,
+		reject
+	};
+};
 const run = (entry, opts) => {
-	const env = typeof process === "object" ? process.env : {};
-	const alepha = entry instanceof Alepha ? entry : Alepha.create({ env: {
-		...env,
-		...opts?.env
-	} });
+	const alepha = entry instanceof Alepha ? entry : Alepha.create({ env: { ...opts?.env } });
 	if (!(entry instanceof Alepha)) {
 		const entries = Array.isArray(entry) ? entry : [entry];
 		for (const e of entries) alepha.with(e);
 	}
-	globalThis.__alepha = alepha;
-	if (env.ALEPHA_CLI_IMPORT) globalThis.__cli_alepha = alepha;
-	if (alepha.isServerless() || alepha.isViteDev() || env.ALEPHA_CLI_IMPORT) return alepha;
-	if (opts?.cluster) {
-		withCluster(entry, opts);
-		return alepha;
-	}
-	(async () => {
-		try {
-			await opts?.configure?.(alepha);
-			await alepha.start();
-			if (opts?.ready) await opts.ready(alepha);
-			if (opts?.once) {
-				await alepha.stop();
-				return alepha;
-			}
-			if (typeof process === "object") for (const trap of [
-				"SIGTERM",
-				"SIGINT",
-				"SIGUSR2",
-				"uncaughtException"
-			]) process.once(trap, async (err) => {
-				if (trap === "uncaughtException") alepha.log?.error("Uncaught Exception", err);
-				else alepha.log?.info("Received signal", { trap });
-				try {
-					await alepha.stop();
-					console.log(" ");
-					process.exit(0);
-				} catch (error) {
-					alepha.log?.error("Alepha failed to stop", error);
-					process.exit(1);
-				}
-			});
-		} catch (error) {
-			alepha.log?.error("Alepha failed to start", error);
-			if (typeof process === "object") process.exit(1);
-		}
-	})();
 	return alepha;
 };
-AlsProvider.create = () => new node_async_hooks.AsyncLocalStorage();
-/**
-* Run Alepha in cluster mode, forking workers based on the number of CPU cores.
-*/
-const withCluster = (entry, opts) => {
-	const numCPUs = (0, node_os.cpus)().length;
-	if (node_cluster.default.isPrimary) for (let i = 0; i < numCPUs; i++) node_cluster.default.fork();
-	else run(entry, {
-		...opts,
-		env: {
-			...opts?.env,
-			APP_NAME: `${opts?.env?.APP_NAME || "P"}-${node_cluster.default.worker?.id}`
-		},
-		cluster: false
-	});
-};
 
 //#endregion
-exports.$atom = $atom;
-exports.$context = $context;
-exports.$env = $env;
-exports.$hook = $hook;
-exports.$inject = $inject;
-exports.$module = $module;
-exports.$use = $use;
-exports.Alepha = Alepha;
-exports.AlephaError = AlephaError;
-exports.AlsProvider = AlsProvider;
-exports.AppNotStartedError = AppNotStartedError;
-exports.Atom = Atom;
-exports.CircularDependencyError = CircularDependencyError;
-exports.CodecManager = CodecManager;
-exports.ContainerLockedError = ContainerLockedError;
-exports.Descriptor = Descriptor;
-exports.EventManager = EventManager;
-exports.HookDescriptor = HookDescriptor;
-exports.InjectDescriptor = InjectDescriptor;
-exports.JsonSchemaCodec = JsonSchemaCodec;
-exports.KIND = KIND;
-exports.Module = Module;
-exports.OPTIONS = OPTIONS;
-exports.SchemaCodec = SchemaCodec;
-exports.StateManager = StateManager;
-exports.TooLateSubstitutionError = TooLateSubstitutionError;
-Object.defineProperty(exports, 'TypeBox', {
-  enumerable: true,
-  get: function () {
-    return typebox;
-  }
-});
-exports.TypeBoxError = TypeBoxError;
-exports.TypeBoxFormat = typebox_format.default;
-Object.defineProperty(exports, 'TypeBoxValue', {
-  enumerable: true,
-  get: function () {
-    return typebox_value;
-  }
-});
-exports.TypeGuard = TypeGuard;
-exports.TypeProvider = TypeProvider;
-exports.createDescriptor = createDescriptor;
-exports.createPagination = createPagination;
-exports.isClass = isClass;
-exports.isDate = isDate;
-exports.isDateTime = isDateTime;
-exports.isDuration = isDuration;
-exports.isEmail = isEmail;
-exports.isFileLike = isFileLike;
-exports.isTime = isTime;
-exports.isTypeFile = isTypeFile;
-exports.isURL = isURL;
-exports.isUUID = isUUID;
-exports.pageMetadataSchema = pageMetadataSchema;
-exports.pageQuerySchema = pageQuerySchema;
-exports.pageSchema = pageSchema;
-exports.run = run;
-exports.t = t;
-//# sourceMappingURL=index.cjs.map
+export { $atom, $context, $env, $hook, $inject, $module, $use, Alepha, AlephaError, AlsProvider, AppNotStartedError, Atom, CircularDependencyError, CodecManager, ContainerLockedError, EventManager, HookPrimitive, InjectPrimitive, JsonSchemaCodec, KIND, Module, OPTIONS, Primitive, SchemaCodec, StateManager, TooLateSubstitutionError, TypeBox, TypeBoxError, TypeBoxFormat, TypeBoxValue, TypeGuard, TypeProvider, createPagination, createPrimitive, isClass, isDate, isDateTime, isDuration, isEmail, isFileLike, isTime, isTypeFile, isURL, isUUID, pageMetadataSchema, pageQuerySchema, pageSchema, run, t };
+//# sourceMappingURL=index.native.js.map