alepha 0.14.4 → 0.15.1

package/dist/core/index.browser.js

@@ -1,7 +1,7 @@
-import { Compile } from "typebox/compile";
 import { Type } from "typebox";
 import Format from "typebox/format";
 import * as Value from "typebox/value";
+import { Compile } from "typebox/compile";
 
 //#region ../../src/core/constants/KIND.ts
 /**
@@ -259,6 +259,7 @@ const $module = (options) => {
 	const $ = class extends Module {
 		options = options;
 		register(alepha) {
+			if (options.atoms) for (const atom of options.atoms) alepha.store.register(atom);
 			if (typeof options.register === "function") {
 				options.register(alepha);
 				return;
@@ -310,7 +311,7 @@ var AlsProvider = class AlsProvider {
 		if (!this.als) return callback();
 		data.registry ??= /* @__PURE__ */ new Map();
 		data.context ??= this.createContextId();
-		return this.als.run(data, callback);
+		return this.als.run({ ...data }, callback);
 	}
 	exists() {
 		return !!this.get("context");
@@ -395,27 +396,6 @@ var JsonSchemaCodec = class extends SchemaCodec {
 	}
 };
 
-//#endregion
-//#region ../../src/core/errors/TypeBoxError.ts
-var TypeBoxError = class extends AlephaError {
-	name = "TypeBoxError";
-	cause;
-	value;
-	constructor(error) {
-		super(`Invalid input: ${error.message}${error.instancePath ? ` at ${error.instancePath}` : ""}`, { cause: error });
-		const params = error.params;
-		if (params?.requiredProperties) this.value = {
-			path: `/${params.requiredProperties[0]}`,
-			message: "must be defined"
-		};
-		else this.value = {
-			path: error.instancePath,
-			message: error.message
-		};
-		this.cause = error;
-	}
-};
-
 //#endregion
 //#region ../../src/core/primitives/$hook.ts
 /**
@@ -461,12 +441,13 @@ const $hook = (options) => createPrimitive(HookPrimitive, options);
 var HookPrimitive = class extends Primitive {
 	called = 0;
 	onInit() {
+		const handler = this.options.handler;
 		this.alepha.events.on(this.options.on, {
 			caller: this.config.service,
 			priority: this.options.priority,
-			callback: async (args) => {
+			callback: (args) => {
 				this.called += 1;
-				await this.options.handler(args);
+				return handler(args);
 			}
 		});
 	}
@@ -907,6 +888,452 @@ var TypeProvider = class TypeProvider {
 };
 const t = new TypeProvider();
 
+//#endregion
+//#region ../../src/core/providers/KeylessJsonSchemaCodec.ts
+const UNSAFE_KEYS = new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+/**
+* KeylessJsonSchemaCodec provides schema-driven JSON encoding without keys.
+*
+* It uses the schema to determine field order, allowing the encoded output
+* to be a simple JSON array instead of an object with keys.
+*/
+var KeylessJsonSchemaCodec = class extends SchemaCodec {
+	cache = /* @__PURE__ */ new Map();
+	textEncoder = new TextEncoder();
+	textDecoder = new TextDecoder();
+	varCounter = 0;
+	useFunctionCompilation = true;
+	maxArrayLength = 1e4;
+	maxStringLength = 1e6;
+	maxDepth = 50;
+	/**
+	* Configure codec options.
+	*/
+	configure(options) {
+		if (options.useFunctionCompilation !== void 0) {
+			this.useFunctionCompilation = options.useFunctionCompilation;
+			this.cache.clear();
+		}
+		if (options.maxArrayLength !== void 0) this.maxArrayLength = options.maxArrayLength;
+		if (options.maxStringLength !== void 0) this.maxStringLength = options.maxStringLength;
+		if (options.maxDepth !== void 0) this.maxDepth = options.maxDepth;
+		return this;
+	}
+	/**
+	* Hook to auto-detect safe mode on configure.
+	* Disables function compilation in browser by default.
+	*/
+	onConfigure = $hook({
+		on: "configure",
+		handler: () => {
+			this.useFunctionCompilation = this.canUseFunction();
+		}
+	});
+	/**
+	* Encode value to a keyless JSON string.
+	*/
+	encodeToString(schema, value) {
+		return this.getCodec(schema).encode(value);
+	}
+	/**
+	* Encode value to binary (UTF-8 encoded keyless JSON).
+	*/
+	encodeToBinary(schema, value) {
+		return this.textEncoder.encode(this.encodeToString(schema, value));
+	}
+	/**
+	* Decode keyless JSON string or binary to value.
+	*/
+	decode(schema, value) {
+		if (value instanceof Uint8Array) {
+			const text = this.textDecoder.decode(value);
+			return this.getCodec(schema).decode(text);
+		}
+		if (typeof value === "string") return this.getCodec(schema).decode(value);
+		if (Array.isArray(value)) return this.reconstructObject(schema, value);
+		return value;
+	}
+	/**
+	* Test if `new Function()` is available (not blocked by CSP).
+	*/
+	canUseFunction() {
+		try {
+			return new Function("return true")() === true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Validate schema keys for prototype pollution.
+	* Uses a visited set to avoid infinite recursion on recursive schemas.
+	*/
+	validateSchemaKeys(schema, depth = 0, visited = /* @__PURE__ */ new Set()) {
+		if (visited.has(schema)) return;
+		visited.add(schema);
+		if (depth > this.maxDepth) throw new AlephaError(`Schema depth exceeds maximum allowed (${this.maxDepth})`);
+		if (t.schema.isObject(schema)) {
+			const props = schema.properties;
+			for (const key of Object.keys(props)) {
+				if (UNSAFE_KEYS.has(key)) throw new AlephaError(`Unsafe schema key "${key}" detected. This key is blocked to prevent prototype pollution.`);
+				this.validateSchemaKeys(props[key], depth + 1, visited);
+			}
+		} else if (t.schema.isArray(schema)) {
+			const arrSchema = schema;
+			this.validateSchemaKeys(arrSchema.items, depth + 1, visited);
+		} else if (t.schema.isUnion(schema) || t.schema.isOptional(schema)) this.validateSchemaKeys(this.unwrap(schema), depth, visited);
+	}
+	/**
+	* Validate array length.
+	*/
+	validateArrayLength(arr) {
+		if (arr.length > this.maxArrayLength) throw new AlephaError(`Array length (${arr.length}) exceeds maximum allowed (${this.maxArrayLength})`);
+	}
+	/**
+	* Validate string length.
+	*/
+	validateStringLength(str) {
+		if (str.length > this.maxStringLength) throw new AlephaError(`String length (${str.length}) exceeds maximum allowed (${this.maxStringLength})`);
+	}
+	/**
+	* Get a compiled codec for the given schema.
+	* Codecs are cached for reuse.
+	*/
+	getCodec(schema) {
+		let c = this.cache.get(schema);
+		if (!c) {
+			c = this.useFunctionCompilation ? this.compileWithFunction(schema) : this.compileInterpreted(schema);
+			this.cache.set(schema, c);
+		}
+		return c;
+	}
+	nextVar() {
+		return `_${this.varCounter++}`;
+	}
+	/**
+	* Compile codec using `new Function()` for maximum performance.
+	* Only used when CSP allows and useFunctionCompilation is true.
+	*/
+	compileWithFunction(schema) {
+		this.varCounter = 0;
+		const encBody = this.genEnc(schema, "v");
+		this.varCounter = 0;
+		const decBody = this.genDec(schema);
+		return {
+			encode: new Function("v", `return JSON.stringify(${encBody});`),
+			decode: new Function("s", `const a=JSON.parse(s);let i=0;${decBody.code}return ${decBody.result};`)
+		};
+	}
+	/**
+	* Compile codec using interpreter-based approach.
+	* Safer (no eval/Function) but slower. Used in browser by default.
+	*/
+	compileInterpreted(schema) {
+		const self = this;
+		return {
+			encode(value) {
+				return JSON.stringify(self.interpretEncode(schema, value));
+			},
+			decode(str) {
+				const ctx = {
+					arr: JSON.parse(str),
+					i: 0
+				};
+				return self.interpretDecode(schema, ctx);
+			}
+		};
+	}
+	interpretEncode(schema, value) {
+		if (t.schema.isString(schema) || t.schema.isNumber(schema) || t.schema.isInteger(schema) || t.schema.isBoolean(schema) || this.isEnum(schema)) return value;
+		if (t.schema.isBigInt(schema)) return `${value}n`;
+		if (t.schema.isArray(schema)) {
+			const arrSchema = schema;
+			if (!Array.isArray(value)) return value;
+			if (t.schema.isString(arrSchema.items) || t.schema.isNumber(arrSchema.items) || t.schema.isInteger(arrSchema.items) || t.schema.isBoolean(arrSchema.items)) return value;
+			return value.map((e) => this.interpretEncode(arrSchema.items, e));
+		}
+		if (t.schema.isObject(schema)) {
+			const objSchema = schema;
+			const props = objSchema.properties;
+			const keys = Object.keys(props);
+			const req = new Set(objSchema.required || []);
+			const result = [];
+			for (const k of keys) {
+				const ps = props[k];
+				const isOpt = !req.has(k) || t.schema.isOptional(ps);
+				const isNullable = this.isNullable(ps);
+				const inner = this.unwrap(ps);
+				const v = value[k];
+				if (isOpt) result.push(v !== void 0 ? this.interpretEncode(inner, v) : null);
+				else if (isNullable) result.push(v !== null ? this.interpretEncode(inner, v) : null);
+				else result.push(this.interpretEncode(inner, v));
+			}
+			return result;
+		}
+		if (t.schema.isOptional(schema) || t.schema.isUnion(schema)) {
+			const inner = this.unwrap(schema);
+			if (this.isNullable(schema)) return value !== null ? this.interpretEncode(inner, value) : null;
+			return value !== void 0 ? this.interpretEncode(inner, value) : null;
+		}
+		return value;
+	}
+	interpretDecode(schema, ctx) {
+		if (t.schema.isString(schema) || t.schema.isNumber(schema) || t.schema.isInteger(schema) || t.schema.isBoolean(schema) || this.isEnum(schema)) return ctx.arr[ctx.i++];
+		if (t.schema.isBigInt(schema)) return BigInt(ctx.arr[ctx.i++].slice(0, -1));
+		if (t.schema.isArray(schema)) {
+			const arrSchema = schema;
+			const arr = ctx.arr[ctx.i++];
+			if (!Array.isArray(arr)) return arr;
+			if (t.schema.isObject(arrSchema.items)) return arr.map((e) => this.interpretDecodeFromValue(arrSchema.items, e));
+			return arr;
+		}
+		if (t.schema.isObject(schema)) {
+			const objSchema = schema;
+			const props = objSchema.properties;
+			const keys = Object.keys(props);
+			const req = new Set(objSchema.required || []);
+			const result = {};
+			for (const k of keys) {
+				const ps = props[k];
+				const isOpt = !req.has(k) || t.schema.isOptional(ps);
+				const isNullable = this.isNullable(ps);
+				const inner = this.unwrap(ps);
+				const val = ctx.arr[ctx.i++];
+				if (isOpt) {
+					if (val !== null) result[k] = this.interpretDecodeFromValue(inner, val);
+				} else if (isNullable) result[k] = val === null ? null : this.interpretDecodeFromValue(inner, val);
+				else result[k] = this.interpretDecodeFromValue(inner, val);
+			}
+			return result;
+		}
+		if (t.schema.isOptional(schema) || t.schema.isUnion(schema)) {
+			const inner = this.unwrap(schema);
+			const val = ctx.arr[ctx.i++];
+			if (val === null) return this.isNullable(schema) ? null : void 0;
+			if (t.schema.isObject(inner) || t.schema.isArray(inner)) return this.interpretDecodeFromValue(inner, val);
+			return val;
+		}
+		return ctx.arr[ctx.i++];
+	}
+	interpretDecodeFromValue(schema, value) {
+		if (t.schema.isString(schema) || t.schema.isNumber(schema) || t.schema.isInteger(schema) || t.schema.isBoolean(schema) || this.isEnum(schema)) return value;
+		if (t.schema.isBigInt(schema)) return BigInt(value.slice(0, -1));
+		if (t.schema.isArray(schema)) {
+			if (!Array.isArray(value)) return value;
+			const arrSchema = schema;
+			if (t.schema.isObject(arrSchema.items)) return value.map((e) => this.interpretDecodeFromValue(arrSchema.items, e));
+			return value;
+		}
+		if (t.schema.isObject(schema)) {
+			const props = schema.properties;
+			const keys = Object.keys(props);
+			const result = {};
+			for (let idx = 0; idx < keys.length; idx++) {
+				const k = keys[idx];
+				const inner = this.unwrap(props[k]);
+				const v = value[idx];
+				if (t.schema.isObject(inner)) result[k] = this.interpretDecodeFromValue(inner, v);
+				else if (t.schema.isBigInt(inner)) result[k] = BigInt(v.slice(0, -1));
+				else result[k] = v;
+			}
+			return result;
+		}
+		return value;
+	}
+	genEnc(schema, ve) {
+		if (t.schema.isString(schema) || t.schema.isNumber(schema) || t.schema.isInteger(schema) || t.schema.isBoolean(schema) || this.isEnum(schema)) return ve;
+		if (t.schema.isBigInt(schema)) return `${ve}+'n'`;
+		if (t.schema.isArray(schema)) {
+			const arrSchema = schema;
+			const itemEnc = this.genEnc(arrSchema.items, "e");
+			if (t.schema.isString(arrSchema.items) || t.schema.isNumber(arrSchema.items) || t.schema.isInteger(arrSchema.items) || t.schema.isBoolean(arrSchema.items)) return ve;
+			return `${ve}.map(e=>${itemEnc})`;
+		}
+		if (t.schema.isObject(schema)) {
+			const objSchema = schema;
+			const props = objSchema.properties;
+			const keys = Object.keys(props);
+			const req = new Set(objSchema.required || []);
+			const parts = [];
+			for (const k of keys) {
+				const ps = props[k];
+				const isOpt = !req.has(k) || t.schema.isOptional(ps);
+				const isNullable = this.isNullable(ps);
+				const inner = this.unwrap(ps);
+				const innerEnc = this.genEnc(inner, `${ve}.${k}`);
+				if (isOpt) parts.push(`${ve}.${k}!==undefined?${innerEnc}:null`);
+				else if (isNullable) parts.push(`${ve}.${k}!==null?${innerEnc}:null`);
+				else parts.push(innerEnc);
+			}
+			return `[${parts.join(",")}]`;
+		}
+		if (t.schema.isOptional(schema) || t.schema.isUnion(schema)) {
+			const inner = this.unwrap(schema);
+			const innerEnc = this.genEnc(inner, ve);
+			if (this.isNullable(schema)) return `${ve}!==null?${innerEnc}:null`;
+			return `${ve}!==undefined?${innerEnc}:null`;
+		}
+		return ve;
+	}
+	genDec(schema) {
+		const v = this.nextVar();
+		if (t.schema.isString(schema) || t.schema.isNumber(schema) || t.schema.isInteger(schema) || t.schema.isBoolean(schema) || this.isEnum(schema)) return {
+			code: "",
+			result: "a[i++]"
+		};
+		if (t.schema.isBigInt(schema)) return {
+			code: "",
+			result: "BigInt(a[i++].slice(0,-1))"
+		};
+		if (t.schema.isArray(schema)) {
+			const arrSchema = schema;
+			if (t.schema.isObject(arrSchema.items)) return {
+				code: "",
+				result: `a[i++].map(e=>${this.genDecFromValue(arrSchema.items, "e")})`
+			};
+			return {
+				code: "",
+				result: "a[i++]"
+			};
+		}
+		if (t.schema.isObject(schema)) {
+			const objSchema = schema;
+			const props = objSchema.properties;
+			const keys = Object.keys(props);
+			const req = new Set(objSchema.required || []);
+			let simple = true;
+			for (const k of keys) {
+				const ps = props[k];
+				const isOpt = !req.has(k) || t.schema.isOptional(ps);
+				const isNullable = this.isNullable(ps);
+				const inner = this.unwrap(ps);
+				if (isOpt || isNullable || t.schema.isObject(inner) || t.schema.isArray(inner)) {
+					simple = false;
+					break;
+				}
+			}
+			if (simple) return {
+				code: "",
+				result: `{${keys.map((k) => `${k}:a[i++]`).join(",")}}`
+			};
+			let code = `const ${v}={};`;
+			for (const k of keys) {
+				const ps = props[k];
+				const isOpt = !req.has(k) || t.schema.isOptional(ps);
+				const isNullable = this.isNullable(ps);
+				const inner = this.unwrap(ps);
+				if (isOpt) {
+					const nested = this.genDecFromValue(inner, "t");
+					code += `{const t=a[i++];if(t!==null){${v}.${k}=${nested};}}`;
+				} else if (isNullable) {
+					const nested = this.genDecFromValue(inner, "t");
+					code += `{const t=a[i++];if(t===null){${v}.${k}=null;}else{${v}.${k}=${nested};}}`;
+				} else if (t.schema.isObject(inner)) {
+					const nested = this.genDecFromValue(inner, "a[i++]");
+					code += `${v}.${k}=${nested};`;
+				} else if (t.schema.isArray(inner)) {
+					const arrSchema = inner;
+					if (t.schema.isObject(arrSchema.items)) {
+						const itemTransform = this.genDecFromValue(arrSchema.items, "e");
+						code += `${v}.${k}=a[i++].map(e=>${itemTransform});`;
+					} else code += `${v}.${k}=a[i++];`;
+				} else code += `${v}.${k}=a[i++];`;
+			}
+			return {
+				code,
+				result: v
+			};
+		}
+		if (t.schema.isOptional(schema) || t.schema.isUnion(schema)) {
+			const inner = this.unwrap(schema);
+			const innerDec = this.genDec(inner);
+			return {
+				code: `const ${v}t=a[i++];let ${v};if(${v}t===null){${v}=${this.isNullable(schema) ? "null" : "undefined"};}else{${innerDec.code.replace(/a\[i\+\+\]/g, `${v}t`)}${v}=${innerDec.result.replace(/a\[i\+\+\]/g, `${v}t`)};}`,
+				result: v
+			};
+		}
+		return {
+			code: "",
+			result: "a[i++]"
+		};
+	}
+	genDecFromValue(schema, expr) {
+		if (t.schema.isString(schema) || t.schema.isNumber(schema) || t.schema.isInteger(schema) || t.schema.isBoolean(schema) || this.isEnum(schema)) return expr;
+		if (t.schema.isBigInt(schema)) return `BigInt(${expr}.slice(0,-1))`;
+		if (t.schema.isArray(schema)) return expr;
+		if (t.schema.isObject(schema)) {
+			const props = schema.properties;
+			const keys = Object.keys(props);
+			const v = this.nextVar();
+			return `((${v}=${expr})=>({${keys.map((k, idx) => {
+				const inner = this.unwrap(props[k]);
+				const innerExpr = `${v}[${idx}]`;
+				if (t.schema.isObject(inner)) return `${k}:${this.genDecFromValue(inner, innerExpr)}`;
+				if (t.schema.isBigInt(inner)) return `${k}:BigInt(${innerExpr}.slice(0,-1))`;
+				return `${k}:${innerExpr}`;
+			}).join(",")}}))()`;
+		}
+		return expr;
+	}
+	isEnum(schema) {
+		return "enum" in schema && Array.isArray(schema.enum) && (schema.enum?.length ?? 0) > 0;
+	}
+	isNullable(schema) {
+		if (!t.schema.isUnion(schema)) return false;
+		return schema.anyOf?.some((s) => t.schema.isNull(s)) ?? false;
+	}
+	unwrap(schema) {
+		if ("anyOf" in schema && Array.isArray(schema.anyOf)) return schema.anyOf.find((s) => !t.schema.isNull(s)) || schema;
+		return schema;
+	}
+	/**
+	* Reconstruct an object from a parsed array (for when input is already parsed).
+	*/
+	reconstructObject(schema, arr) {
+		if (!t.schema.isObject(schema)) return arr;
+		const props = schema.properties;
+		const keys = Object.keys(props);
+		const result = {};
+		let i = 0;
+		for (const k of keys) {
+			const ps = props[k];
+			const isOpt = t.schema.isOptional(ps);
+			const isNullable = this.isNullable(ps);
+			const inner = this.unwrap(ps);
+			const val = arr[i++];
+			if (isOpt) {
+				if (val !== null) result[k] = t.schema.isObject(inner) ? this.reconstructObject(inner, val) : val;
+			} else if (isNullable) result[k] = val === null ? null : t.schema.isObject(inner) ? this.reconstructObject(inner, val) : val;
+			else result[k] = t.schema.isObject(inner) ? this.reconstructObject(inner, val) : val;
+		}
+		return result;
+	}
+};
+
+//#endregion
+//#region ../../src/core/errors/TypeBoxError.ts
+var TypeBoxError = class extends AlephaError {
+	name = "TypeBoxError";
+	cause;
+	value;
+	constructor(error) {
+		super(`Invalid input: ${error.message}${error.instancePath ? ` at ${error.instancePath}` : ""}`, { cause: error });
+		const params = error.params;
+		if (params?.requiredProperties) this.value = {
+			path: `/${params.requiredProperties[0]}`,
+			message: "must be defined"
+		};
+		else this.value = {
+			path: error.instancePath,
+			message: error.message
+		};
+		this.cause = error;
+	}
+};
+
 //#endregion
 //#region ../../src/core/providers/SchemaValidator.ts
 var SchemaValidator = class {
@@ -1001,19 +1428,26 @@ var SchemaValidator = class {
 var CodecManager = class {
 	codecs = /* @__PURE__ */ new Map();
 	jsonCodec = $inject(JsonSchemaCodec);
+	keylessCodec = $inject(KeylessJsonSchemaCodec);
 	schemaValidator = $inject(SchemaValidator);
 	default = "json";
 	constructor() {
-		this.register(this.default, this.jsonCodec);
+		this.register({
+			name: "json",
+			codec: this.jsonCodec,
+			default: true
+		});
+		this.register({
+			name: "keyless",
+			codec: this.keylessCodec
+		});
 	}
 	/**
 	* Register a new codec format.
-	*
-	* @param name - The name of the codec (e.g., 'json', 'protobuf')
-	* @param codec - The codec implementation
 	*/
-	register(name, codec) {
-		this.codecs.set(name, codec);
+	register(opts) {
+		this.codecs.set(opts.name, opts.codec);
+		if (opts.default) this.default = opts.name;
 	}
 	/**
 	* Get a specific codec by name.
@@ -1092,35 +1526,110 @@ var EventManager = class {
 		};
 	}
 	/**
+	* Compiles an event into an optimized executor function.
+	*
+	* Call this after all hooks are registered (e.g., after Alepha.start()).
+	* The returned function checks each hook's return value and awaits promises.
+	* Returns undefined if all hooks are sync, or a Promise if any hook returns one.
+	*
+	* @example
+	* ```ts
+	* // At startup (after hooks are registered)
+	* const onRequest = alepha.events.compile("server:onRequest", { catch: true });
+	*
+	* // In hot path - only await if promise returned
+	* const result = onRequest({ request, route });
+	* if (result) await result;
+	* ```
+	*/
+	compile(event, options = {}) {
+		const hooks = this.events[event];
+		if (!hooks || hooks.length === 0) return () => {};
+		const catchErrors = options.catch ?? false;
+		const log = this.log;
+		const runRemainingAsync = async (startIndex, payload) => {
+			for (let i = startIndex; i < hooks.length; i++) {
+				const hook = hooks[i];
+				try {
+					const result = hook.callback(payload);
+					if (result && typeof result === "object" && "then" in result) if (catchErrors) await result.catch((error) => {
+						log?.error(`${String(event)}(${hook.caller?.name ?? "unknown"}) ERROR`, error);
+					});
+					else await result;
+				} catch (error) {
+					if (catchErrors) log?.error(`${String(event)}(${hook.caller?.name ?? "unknown"}) ERROR`, error);
+					else throw error;
+				}
+			}
+		};
+		return (payload) => {
+			for (let i = 0; i < hooks.length; i++) {
+				const hook = hooks[i];
+				try {
+					const result = hook.callback(payload);
+					if (result && typeof result === "object" && "then" in result) {
+						if (catchErrors) return result.catch((error) => {
+							log?.error(`${String(event)}(${hook.caller?.name ?? "unknown"}) ERROR`, error);
+						}).then(() => runRemainingAsync(i + 1, payload));
+						return result.then(() => runRemainingAsync(i + 1, payload));
+					}
+				} catch (error) {
+					if (catchErrors) log?.error(`${String(event)}(${hook.caller?.name ?? "unknown"}) ERROR`, error);
+					else throw error;
+				}
+			}
+		};
+	}
+	/**
 	* Emits the specified event with the given payload.
+	*
+	* For hot paths (like HTTP request handling), use compile() instead
+	* to get an optimized executor.
 	*/
 	async emit(func, payload, options = {}) {
+		const events = this.events[func];
+		if (!events || events.length === 0) return;
+		if (events.length === 1 && !options.log && !options.reverse) {
+			const hook = events[0];
+			try {
+				const result = hook.callback(payload);
+				if (result && typeof result === "object" && "then" in result) await result;
+			} catch (error) {
+				if (options.catch) {
+					this.log?.error(`${String(func)}(${hook.caller?.name ?? "unknown"}) ERROR`, error);
+					return;
+				}
+				throw error;
+			}
+			return;
+		}
 		const ctx = {};
 		if (options.log) {
-			ctx.now = Date.now();
-			this.log?.trace(`${func} ...`);
+			ctx.now = performance.now();
+			this.log?.trace(`${String(func)} ...`);
 		}
-		let events = this.events[func] ?? [];
-		if (options.reverse) events = events.toReversed();
-		for (const hook of events) {
+		let eventList = events;
+		if (options.reverse) eventList = events.toReversed();
+		for (const hook of eventList) {
 			const name = hook.caller?.name ?? "unknown";
 			if (options.log) {
-				ctx.now2 = Date.now();
-				this.log?.trace(`${func}(${name}) ...`);
+				ctx.now2 = performance.now();
+				this.log?.trace(`${String(func)}(${name}) ...`);
 			}
 			try {
-				await hook.callback(payload);
+				const result = hook.callback(payload);
+				if (result && typeof result === "object" && "then" in result) await result;
 			} catch (error) {
 				if (options.catch) {
-					this.log?.error(`${func}(${name}) ERROR`, error);
+					this.log?.error(`${String(func)}(${name}) ERROR`, error);
 					continue;
 				}
-				if (options.log) throw new AlephaError(`Failed during '${func}()' hook for service: ${name}`, { cause: error });
+				if (options.log) throw new AlephaError(`Failed during '${String(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(`${String(func)}(${name}) OK [${(performance.now() - ctx.now2).toFixed(1)}ms]`);
 		}
-		if (options.log) this.log?.debug(`${func} OK [${Date.now() - ctx.now}ms]`);
+		if (options.log) this.log?.debug(`${String(func)} OK [${(performance.now() - ctx.now).toFixed(1)}ms]`);
 	}
 };
 
@@ -1404,13 +1913,10 @@ var Alepha = class Alepha {
 	* 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
-			};
-			for (const key in state.env) if (state.env[key] === "") delete state.env[key];
-		}
+		if (typeof process === "object" && typeof process.env === "object") state.env = {
+			...state.env,
+			...process.env
+		};
 		const alepha = new Alepha(state);
 		if (alepha.isTest()) {
 			const g = globalThis;
@@ -1768,7 +2274,10 @@ var Alepha = class Alepha {
 				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}`);
+			if (this.started) {
+				const mod = service[MODULE]?.name;
+				throw new ContainerLockedError(`Container is locked. No more services can be added. Attempted to inject '${service.name}' from '${parent?.name}'. ${mod ? `Maybe register module '${mod}' in Alepha.` : ""}`);
+			}
 		}
 		const module = service[MODULE];
 		if (module && typeof module === "function") this.with(module);
@@ -1784,10 +2293,10 @@ var Alepha = class Alepha {
 		if (!transient) registry.set(service, definition);
 		if (instance instanceof Module) {
 			this.modules.push(instance);
-			const parent$1 = __alephaRef.parent;
+			const parent = __alephaRef.parent;
 			__alephaRef.parent = instance.constructor;
 			instance.register(this);
-			__alephaRef.parent = parent$1;
+			__alephaRef.parent = parent;
 		}
 		return instance;
 	}
@@ -2328,5 +2837,5 @@ const run = (entry, opts) => {
 };
 
 //#endregion
-export { $atom, $context, $env, $hook, $inject, $module, $use, Alepha, AlephaError, AlsProvider, AppNotStartedError, Atom, CircularDependencyError, CodecManager, ContainerLockedError, EventManager, Format, HookPrimitive, InjectPrimitive, JsonSchemaCodec, KIND, Module, OPTIONS, Primitive, SchemaCodec, StateManager, TooLateSubstitutionError, Type, TypeBoxError, TypeGuard, TypeProvider, Value, createPagination, createPrimitive, isClass, isFileLike, isTypeFile, isUUID, jsonSchemaToTypeBox, pageMetadataSchema, pageQuerySchema, pageSchema, run, t };
+export { $atom, $context, $env, $hook, $inject, $module, $use, Alepha, AlephaError, AlsProvider, AppNotStartedError, Atom, CircularDependencyError, CodecManager, ContainerLockedError, EventManager, Format, HookPrimitive, InjectPrimitive, JsonSchemaCodec, KIND, KeylessJsonSchemaCodec, Module, OPTIONS, Primitive, SchemaCodec, StateManager, TooLateSubstitutionError, Type, TypeBoxError, TypeGuard, TypeProvider, Value, createPagination, createPrimitive, isClass, isFileLike, isTypeFile, isUUID, jsonSchemaToTypeBox, pageMetadataSchema, pageQuerySchema, pageSchema, run, t };
 //# sourceMappingURL=index.browser.js.map