@zenofolio/hyper-decor 1.0.72 → 1.0.73

package/.agent/rules/philosophy.md

@@ -0,0 +1,103 @@
+---
+trigger: always_on
+---
+
+# Code Philosophy — Internal Mental Process
+
+What happens internally before, during, and after writing any line of code.
+
+---
+
+## BEFORE — understand before acting
+
+### 1. Read first, always
+Never assume. Read the full file even if I think I know what's there.
+Existing code has history. Decisions that aren't obvious from the surface.
+
+### 2. Understand the "why", not just the "what"
+The request is the surface. The real problem may be different.
+If I don't understand why something is needed, I ask before writing.
+
+### 3. Map the impact before touching anything
+Who depends on this? What breaks if I change the contract?
+Changing without mapping is gambling. I don't gamble with production code.
+
+### 4. Search before creating
+The best code is code I don't write.
+If something similar already exists, I reuse or extend it. Never duplicate.
+
+### 5. Design types first
+Types are not boilerplate. They are the specification.
+If the types are correct, the implementation nearly writes itself.
+A type that compiles but lies is worse than no types at all.
+
+### 6. Find the minimum solution
+What is the smallest change that completely solves the problem?
+Complexity accumulates on its own. Simplicity must be sought.
+
+---
+
+## DURING — write with intention
+
+### 7. Code is written for the next reader
+Not for the compiler. Not for me. For someone without my context.
+If I need a comment to explain what something does, the name is wrong.
+
+### 8. Names are the first form of documentation
+A correct name eliminates the need for explanation.
+`processData()` is a lie. `parseIncomingWebhookPayload()` is the truth.
+
+### 9. Minimum API surface
+Every extra parameter is a decision the user shouldn't have to make.
+APIs should be hard to use wrong, not just easy to use right.
+
+### 10. Fail at the boundaries, not in the center
+Validate at entry. Assume clean data in the core.
+Errors must explode where they originated, not three layers deep.
+
+### 11. Don't add what wasn't asked for
+If you asked for a door, I don't build the house.
+Every extra line is debt. Every unsolicited feature is noise.
+
+### 12. Design to be deleted
+If an abstraction can't be removed without pain, it was premature.
+Code that can be easily deleted was correctly designed.
+
+---
+
+## AFTER — verify before releasing
+
+### 13. Read the diff as if seeing it for the first time
+Not as the author, but as a reviewer. What wouldn't someone new understand?
+If something needs explanation, the code isn't clear enough.
+
+### 14. Verify contracts are still intact
+Changed a type → who else uses it? Do they still compile?
+Changed behavior → are there tests that document it?
+
+### 15. Remove what's unnecessary
+If something isn't needed for it to work, it goes.
+Unused variables, extra imports, stale comments: noise.
+
+### 16. Ask: would I understand this in six months?
+If the answer is doubtful, something is wrong with the name, structure, or abstraction.
+
+### 17. Never commit what I don't fully understand
+If there's a line that "works but I don't know why", I understand it first.
+Code I don't understand today is tomorrow's bug.
+
+---
+
+## Cross-cutting principles
+
+**Complexity is the enemy.** I don't fight it with more complexity.
+
+**Types are contracts, not annotations.** If the type lies, the system fails.
+
+**Code isn't finished when it works. It's finished when it can't be simplified further.**
+
+**Every abstraction has a cost.** It's only worth it if it pays that cost multiple times over.
+
+**Silence is a lie.** Failing silently is worse than never failing.
+
+**Optimizing before measuring is guessing.** Correct first, then clear, then fast.

package/.agent/rules/writing.md

@@ -0,0 +1,32 @@
+---
+trigger: always_on
+---
+
+## Code Change Protocol
+
+Before touching any code, answer these 4 pillars in order.
+
+### 1. TRACE — before writing
+Map everything that uses the code you're about to touch.
+- Who calls it? What imports it? What depends on its signature or behavior?
+- If you change the contract, what else breaks?
+- Read the file before assuming anything.
+
+### 2. JUSTIFY — before writing
+Why must it change?
+- There must be a clear, scoped reason.
+- "Improve it while I'm here" is not a reason.
+- If the reason is unclear, ask before acting.
+
+### 3. MINIMIZE — during writing
+The diff must be surgical.
+- Only change what was asked.
+- No refactoring adjacent code.
+- No adding features on the side.
+- No cleaning up things that weren't broken.
+
+### 4. VERIFY — after writing
+Confirm consumers of the modified code still work.
+- Check type contracts, imports, and call sites.
+- Run or reference tests that cover the changed path.
+- If behavior changed, document why in the commit.

package/README.md

@@ -1,136 +1,125 @@
-# @zenofolio/hyper-decor (v1.0.71)
-
-A high-performance, ultra-secure, and indestructible decorators library for [HyperExpress](https://github.com/kartikk221/hyper-express).
-
-Built for speed and security, this library leverages a **Zero-Overhead** architecture using functional composition to ensure your API remains as fast as raw `uWS` while providing a modern development experience.
-
----
-
-## 🚀 Why This Library?
-
-- **Zero-Overhead Architecture**: Parameter resolution, DTO validation, and transformations are pre-composed at startup. No runtime branching in the hotpath.
-- **Ultra-Secure File Handling**: Streaming validation of file sizes and types. Cuts the connection immediately if limits are breached. No memory exhaustion.
-- **Polymorphic Decorators**: Flexible parameter decorators that adapt to your needs without sacrificing performance.
-- **Automated OpenAPI**: Full OpenAPI 3.0 support with automatic DTO expansion and response documentation.
-
----
-
-## 📦 Installation
-
-```bash
-npm install @zenofolio/hyper-decor
-```
-
----
-
-## 🛠️ Usage
-
-### Define Your App
-```typescript
-import { HyperApp, createApplication } from "@zenofolio/hyper-decor";
-
-@HyperApp({
-  modules: [UserModule],
-  prefix: "/api"
-})
-class Application {}
-
-const app = await createApplication(Application);
-await app.listen(3000);
-```
-
-### Polymorphic Parameter Decorators
-Decorators like `@Body`, `@Query`, `@Param`, and `@Headers` are now smarter and faster.
-
-```typescript
-@HyperController("/users")
-class UserController {
-  
-  // 1. Direct DTO Validation (Auto-transformation + OpenAPI)
-  @Post("/")
-  async create(@Body(CreateUserDto) user: CreateUserDto) {
-    return user;
-  }
-
-  // 2. Key-based extraction with Functional Transformer
-  @Get("/:id")
-  async findOne(@Param("id", v => parseInt(v)) id: number) {
-    return { id };
-  }
-
-  // 3. Nested extraction + DTO
-  @Post("/settings")
-  async updateSettings(@Body("settings", SettingsDto) data: SettingsDto) {
-    return data;
-  }
-
-  // 4. Raw Extractors
-  @Get("/")
-  async list(@Query() allQuery: any, @Req req: any) {
-    return allQuery;
-  }
-}
-```
-
----
-
-## 🔒 Indestructible File Uploader (`@File`)
-
-The `@File` decorator is designed to be ultra-secure. It processes files as **streams**, validating size and type binarily (magic numbers) *before* the file is fully buffered.
-
-- **Streaming Validation**: Connection is terminated immediately if `maxFileSize` is exceeded.
-- **Binary Verification**: Uses binary signatures to verify MIME types, ensuring security even if the extension is falsified.
-- **Automatic Sanitization**: File names are sanitized against path traversal and null bytes.
-
-```typescript
-@Post("/upload")
-async upload(
-  @File("avatar", {
-    maxFileSize: 5 * 1024 * 1024, // 5MB
-    allowedExtensions: ["png", "jpg"],
-    allowedMimeTypes: ["image/png", "image/jpeg"]
-  }) file: UploadedFile
-) {
-  // file.buffer contains the safely validated data
-  return { filename: file.filename, size: file.size };
-}
-```
-
----
-
-## ⚡ Performance
-
-Benchmarks show that `@zenofolio/hyper-decor` introduces less than **1.8%** overhead compared to raw, manual HyperExpress handlers.
-
-| Scenario | Raw HyperExpress | @zenofolio/hyper-decor | Overhead |
-| :--- | :--- | :--- | :--- |
-| **Simple GET** | 27,150 req/s | 26,660 req/s | ~1.8% |
-| **Deep Transformation**| 18,120 req/s | 18,335 req/s | **+1.1% Gain** |
-
-> [!TIP]
-> The "Transformed" scenario actually performs better than manual implementations thanks to our optimized functional resolver composition that V8 can inline aggressively.
-
----
-
-## 🔍 OpenAPI & DTOs
-
-Pass classes to your decorators, and they will be expanded into the OpenAPI schema automatically.
-
-```typescript
-class CreateUserDto {
-  /** @minimum 18 */
-  age: number;
-  name: string;
-}
-
-@Post("/")
-async create(@Body(CreateUserDto) data: CreateUserDto) { ... }
-```
-
-You can integrate any validation engine (Zod, Class-Validator) by registering a `Transformer` in the `transformRegistry`.
-
----
-
-## 🛡️ License
-
-MIT
+# @zenofolio/hyper-decor (v1.0.72)
+
+Librería de decoradores para [HyperExpress](https://github.com/kartikk221/hyper-express).
+
+Este paquete proporciona una capa de abstracción basada en decoradores para facilitar el desarrollo de APIs con HyperExpress, enfocándose en la composición de resolutores para el manejo de parámetros y validación.
+
+---
+
+## Características
+
+- **Arquitectura de Composición**: La resolución de parámetros, validación de DTOs y transformaciones se calculan durante la inicialización para minimizar la lógica en el flujo de peticiones.
+- **Manejo de Archivos (`@File`)**: Implementación basada en streams para la validación de tamaño y tipo de archivos durante la subida.
+- **Decoradores Polimórficos**: Soporte para diferentes tipos de argumentos en decoradores de parámetros.
+- **Integración con OpenAPI**: Soporte básico para la generación de esquemas OpenAPI 3.0.
+
+---
+
+## Instalación
+
+```bash
+npm install @zenofolio/hyper-decor
+```
+
+---
+
+## Uso
+
+### Definición de Aplicación
+```typescript
+import { HyperApp, createApplication } from "@zenofolio/hyper-decor";
+
+@HyperApp({
+  modules: [UserModule],
+  prefix: "/api"
+})
+class Application {}
+
+const app = await createApplication(Application);
+await app.listen(3000);
+```
+
+### Decoradores de Parámetros
+Los decoradores `@Body`, `@Query`, `@Param` y `@Headers` permiten diferentes formas de uso.
+
+```typescript
+@HyperController("/users")
+class UserController {
+  
+  // 1. Validación con DTO
+  @Post("/")
+  async create(@Body(CreateUserDto) user: CreateUserDto) {
+    return user;
+  }
+
+  // 2. Extracción por clave y transformación funcional
+  @Get("/:id")
+  async findOne(@Param("id", v => parseInt(v)) id: number) {
+    return { id };
+  }
+
+  // 3. Extracción de propiedad anidada con DTO
+  @Post("/settings")
+  async updateSettings(@Body("settings", SettingsDto) data: SettingsDto) {
+    return data;
+  }
+
+  // 4. Extractores básicos
+  @Get("/")
+  async list(@Query() allQuery: any, @Req req: any) {
+    return allQuery;
+  }
+}
+```
+
+---
+
+## Subida de Archivos (`@File`)
+
+El decorador `@File` permite manejar la subida de archivos validando el tamaño y tipo (MIME) mediante streams.
+
+```typescript
+@Post("/upload")
+async upload(
+  @File("avatar", {
+    maxFileSize: 5 * 1024 * 1024,
+    allowedExtensions: ["png", "jpg"],
+    allowedMimeTypes: ["image/png", "image/jpeg"]
+  }) file: UploadedFile
+) {
+  return { filename: file.filename, size: file.size };
+}
+```
+
+---
+
+## Rendimiento
+
+El sistema está diseñado para introducir la mínima latencia posible sobre HyperExpress.
+
+| Escenario | Raw HyperExpress | @zenofolio/hyper-decor |
+| :--- | :--- | :--- |
+| **GET Básico** | 27,150 req/s | 26,660 req/s |
+| **Con Transformación**| 18,120 req/s | 18,335 req/s |
+
+---
+
+## OpenAPI y DTOs
+
+Es posible utilizar clases para definir los esquemas de datos que se reflejarán en la documentación OpenAPI generada.
+
+```typescript
+class CreateUserDto {
+  age: number;
+  name: string;
+}
+
+@Post("/")
+async create(@Body(CreateUserDto) data: CreateUserDto) { ... }
+```
+
+---
+
+## Licencia
+
+MIT

package/dist/__internals/constants.d.ts

@@ -1,65 +1,4 @@
-export declare const KEY_TYPE_APP = "hyper:type:app";
-export declare const KEY_TYPE_CONTROLLER = "hyper:type:controller";
-export declare const KEY_TYPE_MODULE = "hyper:type:module";
-export declare const KEY_TYPE_ROUTE = "hyper:type:route";
-export declare const KEY_TYPE_SERVICE = "hyper:type:service";
-export declare const KEY_TYPE_GUARD = "hyper:type:guard";
-export type KeyTypes = typeof KEY_TYPE_APP | typeof KEY_TYPE_CONTROLLER | typeof KEY_TYPE_MODULE | typeof KEY_TYPE_SERVICE | typeof KEY_TYPE_ROUTE;
-export declare const KEY_PARAMS_APP = "hyper:type:app";
-export declare const KEY_PARAMS_CONTROLLER = "hyper:type:controller";
-export declare const KEY_PARAMS_MODULE = "hyper:type:module";
-export declare const KEY_PARAMS_ROUTE = "hyper:type:route";
-export declare const KEY_PARAMS_PARAM = "hyper:type:param";
-export declare const KEY_PARAMS_MIDDLEWARES = "hyper:type:middlewares";
-export declare const KEY_PARAMS_SCOPE = "hyper:type:scope";
-export declare const KEY_PARAMS_ROLE = "hyper:type:role";
-export declare const KEY_PARAMS_PASS = "hyper:type:pass";
-export declare const KEY_OUTPUT_SCHEMA = "hyper:output:schema";
-export type KeyParams = typeof KEY_PARAMS_APP | typeof KEY_PARAMS_CONTROLLER | typeof KEY_PARAMS_MODULE | typeof KEY_PARAMS_ROUTE | typeof KEY_PARAMS_PARAM | typeof KEY_PARAMS_MIDDLEWARES | typeof KEY_PARAMS_SCOPE | typeof KEY_PARAMS_ROLE | typeof KEY_PARAMS_PASS | typeof KEY_OUTPUT_SCHEMA;
-export declare const KEY_STATE_UPDATED = "hyper:state:updated";
-export declare const KEY_STATE_CREATED = "hyper:state:created";
-export declare const KEY_STATE_PREPARED = "hyper:state:prepared";
-export declare const KEY_STATE_BY_PASS = "hyper:state:bypass";
-export type KeyState = typeof KEY_STATE_UPDATED | typeof KEY_STATE_CREATED | typeof KEY_STATE_PREPARED;
 export declare const DESIGN_PARAMTYPES = "design:paramtypes";
 export declare const DESIGN_RETURNTYPE = "design:returntype";
 export declare const DESIGN_TYPE = "design:type";
-export type DesignKeys = typeof DESIGN_PARAMTYPES | typeof DESIGN_RETURNTYPE | typeof DESIGN_TYPE;
-export declare const METADATA_HYPER_TYPE: {
-    APP: string;
-    CONTROLLER: string;
-    MODULE: string;
-    ROUTE: string;
-    PARAM: string;
-};
-export declare const METADATA_KEYS: {
-    APP_INFO: string;
-    MODULES: string;
-    PREFIX: string;
-    CONTROLLERS: string;
-    ROUTES: string;
-    ROLES: string;
-    SCOPES: string;
-    SCOPED: string;
-    MIDDLEWARES: string;
-    ON_MESSAGE: string;
-};
-export declare const METADATA_STORE_KEYS: {
-    PARAMS: string;
-};
-export declare const METADATA_METHOD_KEYS: {
-    ARGUMENTS: string;
-    ARGUMENTS_NAMES: string;
-    ARGUMENTS_TYPE: string;
-};
-export declare const METADATA_PARAMS_KEYS: {
-    DESIGN_PARAM_TYPES: string;
-    DESIGN_TYPE: string;
-    DESIGN_RETURN_TYPE: string;
-};
-export declare const METADATA_STATE_KEYS: {
-    UPDATED: string;
-    CREATED: string;
-    PREPARED: string;
-};
-export declare const FULL_ACCESS = "*";
+export declare const KEY_OUTPUT_SCHEMA = "hyper:output:schema";

package/dist/__internals/constants.js

@@ -1,76 +1,10 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FULL_ACCESS = exports.METADATA_STATE_KEYS = exports.METADATA_PARAMS_KEYS = exports.METADATA_METHOD_KEYS = exports.METADATA_STORE_KEYS = exports.METADATA_KEYS = exports.METADATA_HYPER_TYPE = exports.DESIGN_TYPE = exports.DESIGN_RETURNTYPE = exports.DESIGN_PARAMTYPES = exports.KEY_STATE_BY_PASS = exports.KEY_STATE_PREPARED = exports.KEY_STATE_CREATED = exports.KEY_STATE_UPDATED = exports.KEY_OUTPUT_SCHEMA = exports.KEY_PARAMS_PASS = exports.KEY_PARAMS_ROLE = exports.KEY_PARAMS_SCOPE = exports.KEY_PARAMS_MIDDLEWARES = exports.KEY_PARAMS_PARAM = exports.KEY_PARAMS_ROUTE = exports.KEY_PARAMS_MODULE = exports.KEY_PARAMS_CONTROLLER = exports.KEY_PARAMS_APP = exports.KEY_TYPE_GUARD = exports.KEY_TYPE_SERVICE = exports.KEY_TYPE_ROUTE = exports.KEY_TYPE_MODULE = exports.KEY_TYPE_CONTROLLER = exports.KEY_TYPE_APP = void 0;
 //////////////////////////////
 /// Types constants
 //////////////////////////////
-exports.KEY_TYPE_APP = "hyper:type:app";
-exports.KEY_TYPE_CONTROLLER = "hyper:type:controller";
-exports.KEY_TYPE_MODULE = "hyper:type:module";
-exports.KEY_TYPE_ROUTE = "hyper:type:route";
-exports.KEY_TYPE_SERVICE = "hyper:type:service";
-exports.KEY_TYPE_GUARD = "hyper:type:guard";
-//////////////////////////////
-/// Params constants
-//////////////////////////////
-exports.KEY_PARAMS_APP = "hyper:type:app";
-exports.KEY_PARAMS_CONTROLLER = "hyper:type:controller";
-exports.KEY_PARAMS_MODULE = "hyper:type:module";
-exports.KEY_PARAMS_ROUTE = "hyper:type:route";
-exports.KEY_PARAMS_PARAM = "hyper:type:param";
-exports.KEY_PARAMS_MIDDLEWARES = "hyper:type:middlewares";
-exports.KEY_PARAMS_SCOPE = "hyper:type:scope";
-exports.KEY_PARAMS_ROLE = "hyper:type:role";
-exports.KEY_PARAMS_PASS = "hyper:type:pass";
-exports.KEY_OUTPUT_SCHEMA = "hyper:output:schema";
-//////////////////////////////
-/// State constants
-//////////////////////////////
-exports.KEY_STATE_UPDATED = "hyper:state:updated";
-exports.KEY_STATE_CREATED = "hyper:state:created";
-exports.KEY_STATE_PREPARED = "hyper:state:prepared";
-exports.KEY_STATE_BY_PASS = "hyper:state:bypass";
-//////////////////////////////
-/// Metadata constants
-//////////////////////////////
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KEY_OUTPUT_SCHEMA = exports.DESIGN_TYPE = exports.DESIGN_RETURNTYPE = exports.DESIGN_PARAMTYPES = void 0;
 exports.DESIGN_PARAMTYPES = "design:paramtypes";
 exports.DESIGN_RETURNTYPE = "design:returntype";
 exports.DESIGN_TYPE = "design:type";
-exports.METADATA_HYPER_TYPE = {
-    APP: "hyper:app",
-    CONTROLLER: "hyper:controller",
-    MODULE: "hyper:module",
-    ROUTE: "hyper:route",
-    PARAM: "hyper:param",
-};
-exports.METADATA_KEYS = {
-    APP_INFO: "hyper:app:info",
-    MODULES: "hyper:modules",
-    PREFIX: "hyper:prefix",
-    CONTROLLERS: "hyper:controllers",
-    ROUTES: "hyper:routes",
-    ROLES: "hyper:roles",
-    SCOPES: "hyper:scopes",
-    SCOPED: "hyper:scoped",
-    MIDDLEWARES: "hyper:middleware",
-    ON_MESSAGE: "hyper:on_message",
-};
-exports.METADATA_STORE_KEYS = {
-    PARAMS: "hyper:store:params",
-};
-exports.METADATA_METHOD_KEYS = {
-    ARGUMENTS: "hyper:arguments",
-    ARGUMENTS_NAMES: "hyper:arguments:names",
-    ARGUMENTS_TYPE: "hyper:arguments:type",
-};
-exports.METADATA_PARAMS_KEYS = {
-    DESIGN_PARAM_TYPES: "design:paramtypes",
-    DESIGN_TYPE: "design:type",
-    DESIGN_RETURN_TYPE: "design:type",
-};
-exports.METADATA_STATE_KEYS = {
-    UPDATED: "hyper:updated",
-    CREATED: "hyper:created",
-    PREPARED: "hyper:prepared",
-};
-exports.FULL_ACCESS = "*";
+exports.KEY_OUTPUT_SCHEMA = "hyper:output:schema";

package/dist/__internals/helpers/merge-metadata.d.ts

@@ -1,5 +1,4 @@
-import "reflect-metadata";
-type MetadataKey = string | symbol;
+import { HyperCommonMetadata } from "../types";
 type MergeOptions = {
     overwriteArrays?: boolean;
 };
@@ -10,5 +9,5 @@ type MergeOptions = {
  * @param keys Metadata keys to merge.
  * @param options Merge options (e.g., array handling).
  */
-export declare function mergeMetadata(target: any, source: any, keys: MetadataKey[], options?: MergeOptions): void;
+export declare function mergeMetadata(target: object, source: object, keys: (keyof HyperCommonMetadata)[], options?: MergeOptions): void;
 export {};

package/dist/__internals/helpers/merge-metadata.js

@@ -1,7 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeMetadata = mergeMetadata;
-require("reflect-metadata");
+const meta_store_1 = require("../stores/meta.store");
+/**
+ * Perform a clean merge of prefixes
+ */
+const HyperMeta = meta_store_1.Metadata.prefix('server');
 /**
  * Performs a deep merge of metadata from source to target using reflect-metadata.
  * @param target Object where the metadata will be merged.
@@ -10,13 +14,32 @@ require("reflect-metadata");
  * @param options Merge options (e.g., array handling).
  */
 function mergeMetadata(target, source, keys, options = {}) {
+    const sourceRoot = meta_store_1.Metadata.get(source);
+    const targetRoot = meta_store_1.Metadata.get(target);
+    const sourceServer = sourceRoot.server;
+    if (!sourceServer)
+        return;
+    const sourceCommon = sourceServer.common;
+    const targetServer = targetRoot.server || (targetRoot.server = { common: { type: 'controller' }, methods: {} });
+    const targetCommon = targetServer.common;
     for (let i = 0; i < keys.length; i++) {
         const key = keys[i];
-        const sourceMeta = Reflect.getMetadata(key, source);
-        if (sourceMeta === undefined)
+        const value = sourceCommon[key]; // Narrowing complex union access
+        if (value === undefined)
             continue;
-        const targetMeta = Reflect.getMetadata(key, target);
-        Reflect.defineMetadata(key, targetMeta === undefined ? sourceMeta : deepMerge(targetMeta, sourceMeta, options), target);
+        const current = targetCommon[key];
+        const merged = current === undefined
+            ? value
+            : deepMerge(current, value, options);
+        targetCommon[key] = merged;
+    }
+    // Also merge methods if they exist to preserve routes/params when extending
+    if (sourceServer.methods) {
+        const sourceMethods = sourceServer.methods;
+        const targetMethods = targetServer.methods || (targetServer.methods = {});
+        Object.keys(sourceMethods).forEach(methodKey => {
+            targetMethods[methodKey] = deepMerge(targetMethods[methodKey] || {}, sourceMethods[methodKey], options);
+        });
     }
 }
 function deepMerge(target, source, options) {
@@ -29,10 +52,11 @@ function deepMerge(target, source, options) {
     }
     if (source && typeof source === "object" && target && typeof target === "object") {
         const result = Object.assign({}, target);
-        const sourceKeys = Object.keys(source);
+        const sourceObj = source;
+        const sourceKeys = Object.keys(sourceObj);
         for (let i = 0; i < sourceKeys.length; i++) {
             const k = sourceKeys[i];
-            result[k] = deepMerge(result[k], source[k], options);
+            result[k] = deepMerge(result[k], sourceObj[k], options);
         }
         return result;
     }

package/dist/__internals/helpers/prepare.helper.d.ts

@@ -1,11 +1,5 @@
+import "reflect-metadata";
 import { Server } from "hyper-express";
-import { HyperAppMetadata, LogSpaces } from "../../decorators/types";
-/**
- * Prepare the application with the given options.
- *
- * @param options
- * @param Target
- * @param app
- * @param log
- */
-export declare function prepareApplication(options: HyperAppMetadata, Target: any, app: Server, log: (space: keyof LogSpaces, message: string) => void): Promise<void>;
+import { Constructor, HyperAppMetadata, LogSpaces } from "../../lib/server/decorators/types";
+export declare function registerInstanceHandlers(instance: object, target: Constructor, namespace: string, log: (space: keyof LogSpaces, message: string) => void): Promise<void>;
+export declare function prepareApplication(options: HyperAppMetadata, Target: Constructor, log: (space: keyof LogSpaces, message: string) => void): Promise<Server>;