@xeno-js/cli 0.1.2 → 0.1.4

package/dist/index.js

@@ -474,20 +474,27 @@ var init_generate_command_generator = __esm({
       }
       _fileService;
       async generate(pascalName, lowerName, tokenPrefix, componentDir, hasZod, hasDrizzle) {
+        const appDir = import_node_path.default.join(componentDir, "application");
+        const infraDir = import_node_path.default.join(componentDir, "infrastructure");
+        const domainDir = import_node_path.default.join(componentDir, "domain");
+        const presDir = import_node_path.default.join(componentDir, "presentation");
         const commandContent = `import { Command } from '@xeno-js/core';
+export interface ${pascalName}Payload {
+    // TODO: Define your command payload properties here
+}
 
 /*
  * \u26A0\uFE0F WARNING: ACTION REQUIRED \u26A0\uFE0F
- * Please replace <any> with your specific payload and response types.
+ * Please replace <void> with your specific payload and response types.
  */
-export class ${pascalName}Command extends Command<any> {
-    constructor(public readonly payload: any) {
+export class ${pascalName}Command extends Command<void> {
+    constructor(public readonly payload: ${pascalName}Payload) {
         super('${tokenPrefix}_COMMAND_HANDLER');
     }
 }
 `;
         await this._fileService.writeFileRecursive(
-          import_node_path.default.join(componentDir, `${lowerName}.command.ts`),
+          import_node_path.default.join(appDir, `${lowerName}.command.ts`),
           commandContent
         );
         const handlerContent = `import type { IFactory, ResultType, UserContext } from '@xeno-js/core';
@@ -496,16 +503,16 @@ import { ${pascalName}Command } from './${lowerName}.command';
 
 /*
  * \u26A0\uFE0F WARNING: ACTION REQUIRED \u26A0\uFE0F
- * Please replace <any> with your specific response type.
+ * Please replace <void> with your specific response type.
  */
-export class ${pascalName}Handler extends BaseHandler<${pascalName}Command, any> {
+export class ${pascalName}Handler extends BaseHandler<${pascalName}Command, void> {
     constructor(
         identityFactory: IFactory<void, UserContext>
     ) {
         super(identityFactory);
     }
 
-    public async executeAsync(request: ${pascalName}Command, singal: AbortSignal): Promise<ResultType<any>> {
+    protected async executeAsync(request: ${pascalName}Command, singal: AbortSignal): Promise<ResultType<void>> {
         // TODO: Implement your business logic here
 
         return Result.ok();
@@ -513,18 +520,18 @@ export class ${pascalName}Handler extends BaseHandler<${pascalName}Command, any>
 }
 `;
         await this._fileService.writeFileRecursive(
-          import_node_path.default.join(componentDir, `${lowerName}.handler.ts`),
+          import_node_path.default.join(appDir, `${lowerName}.handler.ts`),
           handlerContent
         );
         const controllerContent = `import type { IContextAccessor, IMediator, RequestContext, ResponseDto } from '@xeno-js/core';
 import { BaseController } from '@xeno-js/core';
-import { ${pascalName}Command } from './${lowerName}.command';
+import { ${pascalName}Command, ${pascalName}Payload } from '../application/${lowerName}.command';
 
 /*
  * \u26A0\uFE0F WARNING: ACTION REQUIRED \u26A0\uFE0F
- * Please replace <any, any> with your specific request and response types.
+ * Please replace <{pascalName}Payload, void> with your specific request and response types.
  */
-export class ${pascalName}Controller extends BaseController<any, any> {
+export class ${pascalName}Controller extends BaseController<${pascalName}Payload, void> {
     constructor(
         requestContext: IContextAccessor<RequestContext>,
         mediator: IMediator,
@@ -532,7 +539,7 @@ export class ${pascalName}Controller extends BaseController<any, any> {
         super(requestContext, mediator);
     }
 
-    public async handle(request: any): Promise<ResponseDto<any>> {
+    public async handle(request: {pascalName}Payload): Promise<ResponseDto<void>> {
         const cmd = new ${pascalName}Command(request);
         const result = await this._send(cmd);
 
@@ -545,7 +552,7 @@ export class ${pascalName}Controller extends BaseController<any, any> {
 }
 `;
         await this._fileService.writeFileRecursive(
-          import_node_path.default.join(componentDir, `${lowerName}.controller.ts`),
+          import_node_path.default.join(presDir, `${lowerName}.controller.ts`),
           controllerContent
         );
         const entityContent = `import { Entity } from '@xeno-js/core';
@@ -569,23 +576,27 @@ export class ${pascalName} extends Entity<${pascalName}Props> {
 }
 `;
         await this._fileService.writeFileRecursive(
-          import_node_path.default.join(componentDir, `${lowerName}.entity.ts`),
+          import_node_path.default.join(domainDir, `${lowerName}.entity.ts`),
           entityContent
         );
         if (hasZod) {
           const zodContent = `import { z } from 'zod';
 import { ZodUtils } from '@xeno-js/core';
 
-/*
+/**
  * \u26A0\uFE0F WARNING: ACTION REQUIRED \u26A0\uFE0F
  * Define the actual Zod validation schema for your command payload.
  */
 export const ${pascalName}Schema = ZodUtils.createCommandSchema({
-    payload: z.any() // TODO: Update with strict validation
+    payload: z.object({
+        // TODO: Define strict validation rules here, e.g.:
+        // email: z.string().email(),
+        // name: z.string().min(1),
+    }),
 });
 `;
           await this._fileService.writeFileRecursive(
-            import_node_path.default.join(componentDir, `${lowerName}.schema-zod.ts`),
+            import_node_path.default.join(infraDir, `${lowerName}.schema-zod.ts`),
             zodContent
           );
         }
@@ -607,14 +618,14 @@ export type ${pascalName}Dto = typeof ${lowerName}s.$inferSelect;
 export type New${pascalName}Dto = typeof ${lowerName}s.$inferInsert;
 `;
           await this._fileService.writeFileRecursive(
-            import_node_path.default.join(componentDir, `${lowerName}.schema-db.ts`),
+            import_node_path.default.join(infraDir, `${lowerName}.schema-db.ts`),
             dbContent
           );
         }
         const moduleContent = `import type { IServiceContainer, IConfigurationService } from '@xeno-js/core';
 import { TOKENS } from '@xeno-js/core';
-import { ${pascalName}Controller } from './${lowerName}.controller';
-import { ${pascalName}Handler } from './${lowerName}.handler';
+import { ${pascalName}Controller } from './presentation/${lowerName}.controller';
+import { ${pascalName}Handler } from './application/${lowerName}.handler';
 
 export const ${pascalName}Module = Object.freeze({
     register(opts: IServiceContainer<any>, _config: IConfigurationService): void {
@@ -656,14 +667,21 @@ var init_generate_query_generator = __esm({
       }
       _fileService;
       async generate(pascalName, lowerName, tokenPrefix, componentDir, hasZod) {
+        const appDir = import_node_path2.default.join(componentDir, "application");
+        const infraDir = import_node_path2.default.join(componentDir, "infrastructure");
+        const domainDir = import_node_path2.default.join(componentDir, "domain");
+        const presDir = import_node_path2.default.join(componentDir, "presentation");
         const queryContent = `import { BaseQuery } from '@xeno-js/core';
+export interface ${pascalName}Payload {
+    // TODO: Define your command payload properties here
+}
 
 /*
  * \u26A0\uFE0F WARNING: ACTION REQUIRED \u26A0\uFE0F
- * Please replace <any> with your specific payload and response types.
+ * Please replace <void> with your specific payload and response types.
  */
-export class ${pascalName}Query extends BaseQuery<any> {
-    constructor(public readonly payload: any) {
+export class ${pascalName}Query extends BaseQuery<void> {
+    constructor(public readonly payload: ${pascalName}Payload) {
         super(
             '${tokenPrefix}_QUERY_HANDLER', 
             // Default cache options:
@@ -679,7 +697,7 @@ export class ${pascalName}Query extends BaseQuery<any> {
 }
 `;
         await this._fileService.writeFileRecursive(
-          import_node_path2.default.join(componentDir, `${lowerName}.query.ts`),
+          import_node_path2.default.join(appDir, `${lowerName}.query.ts`),
           queryContent
         );
         const handlerContent = `import type { IFactory, ResultType, UserContext } from '@xeno-js/core';
@@ -688,9 +706,9 @@ import { ${pascalName}Query } from './${lowerName}.query';
 
 /*
  * \u26A0\uFE0F WARNING: ACTION REQUIRED \u26A0\uFE0F
- * Please replace <any> with your specific response type.
+ * Please replace <void> with your specific response type.
  */
-export class ${pascalName}Handler extends BaseHandler<${pascalName}Query, any> {
+export class ${pascalName}Handler extends BaseHandler<${pascalName}Query, void> {
     constructor(
         identityFactory: IFactory<void, UserContext>
         // TODO: Inject your ReadDao or DataSource here
@@ -698,7 +716,7 @@ export class ${pascalName}Handler extends BaseHandler<${pascalName}Query, any> {
         super(identityFactory);
     }
 
-    public async executeAsync(request: ${pascalName}Query, singal: AbortSignal): Promise<ResultType<any>> {
+    protected async executeAsync(request: ${pascalName}Query, singal: AbortSignal): Promise<ResultType<void>> {
         // TODO: Implement your query logic here
 
         return Result.ok();
@@ -706,18 +724,18 @@ export class ${pascalName}Handler extends BaseHandler<${pascalName}Query, any> {
 }
 `;
         await this._fileService.writeFileRecursive(
-          import_node_path2.default.join(componentDir, `${lowerName}.handler.ts`),
+          import_node_path2.default.join(appDir, `${lowerName}.handler.ts`),
           handlerContent
         );
         const controllerContent = `import type { IContextAccessor, IMediator, RequestContext, ResponseDto } from '@xeno-js/core';
 import { BaseController } from '@xeno-js/core';
-import { ${pascalName}Query } from './${lowerName}.query';
+import { ${pascalName}Query, ${pascalName}Payload } from '../presentation/${lowerName}.query';
 
 /*
  * \u26A0\uFE0F WARNING: ACTION REQUIRED \u26A0\uFE0F
- * Please replace <any, any> with your specific request and response types.
+ * Please replace <${pascalName}Payload, void> with your specific request and response types.
  */
-export class ${pascalName}Controller extends BaseController<any, any> {
+export class ${pascalName}Controller extends BaseController<${pascalName}Payload, void> {
     constructor(
         requestContext: IContextAccessor<RequestContext>,
         mediator: IMediator,
@@ -725,7 +743,7 @@ export class ${pascalName}Controller extends BaseController<any, any> {
         super(requestContext, mediator);
     }
 
-    public async handle(request: any): Promise<ResponseDto<any>> {
+    public async handle(request: ${pascalName}Payload): Promise<ResponseDto<void>> {
         const query = new ${pascalName}Query(request);
         const result = await this._query(query);
 
@@ -738,23 +756,51 @@ export class ${pascalName}Controller extends BaseController<any, any> {
 }
 `;
         await this._fileService.writeFileRecursive(
-          import_node_path2.default.join(componentDir, `${lowerName}.controller.ts`),
+          import_node_path2.default.join(presDir, `${lowerName}.controller.ts`),
           controllerContent
         );
+        const entityContent = `import { Entity } from '@xeno-js/core';
+        
+        export interface ${pascalName}Props {
+            // TODO: Define your entity properties
+        }
+        
+        /*
+         * \u26A0\uFE0F WARNING: ACTION REQUIRED \u26A0\uFE0F
+         * Adjust the properties and types according to your domain logic.
+         */
+        export class ${pascalName} extends Entity<${pascalName}Props> {
+            private constructor(props: ${pascalName}Props, id?: string) {
+                super(props, id);
+            }
+        
+            static create(props: ${pascalName}Props, id?: string): ${pascalName} {
+                return new ${pascalName}(props, id);
+            }
+        }
+        `;
+        await this._fileService.writeFileRecursive(
+          import_node_path2.default.join(domainDir, `${lowerName}.entity.ts`),
+          entityContent
+        );
         if (hasZod) {
           const zodContent = `import { z } from 'zod';
 import { ZodUtils } from '@xeno-js/core';
 
-/*
+/**
  * \u26A0\uFE0F WARNING: ACTION REQUIRED \u26A0\uFE0F
- * Define the actual Zod validation schema for your query payload.
+ * Define the actual Zod validation schema for your command payload.
  */
-export const ${pascalName}Schema = ZodUtils.createQuerySchema({
-    payload: z.any() // TODO: Update with strict validation
+export const ${pascalName}Schema = ZodUtils.createCommandSchema({
+    payload: z.object({
+        // TODO: Define strict validation rules here, e.g.:
+        // email: z.string().email(),
+        // name: z.string().min(1),
+    }),
 });
 `;
           await this._fileService.writeFileRecursive(
-            import_node_path2.default.join(componentDir, `${lowerName}.schema-zod.ts`),
+            import_node_path2.default.join(infraDir, `${lowerName}.schema-zod.ts`),
             zodContent
           );
         }
@@ -772,8 +818,8 @@ export const ${pascalName}Module = Object.freeze({
          * \u26A0\uFE0F WARNING: ACTION REQUIRED \u26A0\uFE0F
          * Please copy and paste the following tokens to your MyRegistry interface (usually in src/registry.ts):
          *
-         * ${tokenPrefix}_QUERY_CONTROLLER: IController<any, any>;
-         * ${tokenPrefix}_QUERY_HANDLER: IHandler<${pascalName}Query, any>;
+         * ${tokenPrefix}_QUERY_CONTROLLER: IController<${pascalName}Query, void>;
+         * ${tokenPrefix}_QUERY_HANDLER: IHandler<${pascalName}Query, void>;
          */
     }
 } as const);
@@ -866,6 +912,9 @@ var init_generate_command_vue_generator = __esm({
       }
       _fileService;
       async generate(pascalName, lowerName, tokenPrefix, componentDir) {
+        const appDir = import_node_path4.default.join(componentDir, "application");
+        const domainDir = import_node_path4.default.join(componentDir, "domain");
+        const presDir = import_node_path4.default.join(componentDir, "presentation");
         const commandContent = `import { Command } from '@xeno-js/vue';
 
 export class ${pascalName}Command extends Command {
@@ -875,13 +924,13 @@ export class ${pascalName}Command extends Command {
 }
 `;
         await this._fileService.writeFileRecursive(
-          import_node_path4.default.join(componentDir, `${lowerName}.command.ts`),
+          import_node_path4.default.join(appDir, `${lowerName}.command.ts`),
           commandContent
         );
-        const handlerContent = `import type { IHandler, ResultType } from '@xeno-js/vue';
-import { AppError, Result } from '@xeno-js/vue';
+        const handlerContent = `import type { ResultType } from '@xeno-js/vue';
+import { AppError, BaseHandler, Result } from '@xeno-js/vue';
 import type { ${pascalName}Command } from './${lowerName}.command';
-import type { ${pascalName}Response } from './${lowerName}.model';
+import type { ${pascalName}Response } from '../entity/${lowerName}.model';
 
 /*
  * \u26A0\uFE0F WARNING: ACTION REQUIRED \u26A0\uFE0F
@@ -896,28 +945,26 @@ import type { ${pascalName}Response } from './${lowerName}.model';
  *     register('${tokenPrefix}_HANDLER', new ${pascalName}Handler());
  * });
  */
-export class ${pascalName}Handler implements IHandler<${pascalName}Command, ${pascalName}Response> {
+export class ${pascalName}Handler extends BaseHandler<${pascalName}Command, ${pascalName}Response> {
     constructor(
         // TODO: Inject your remote DataSources or other services here
     ) {}
 
-    public async handle(command: ${pascalName}Command, signal: AbortSignal): Promise<ResultType<${pascalName}Response>> {
-        AppError.throwIfAborted(signal, this.constructor.name);
-
+    protected async executeAsync(command: ${pascalName}Command, signal: AbortSignal): Promise<ResultType<${pascalName}Response>> {
         // TODO: Implement your frontend business logic or API calls here
         return Result.ok();
     }
 }
 `;
         await this._fileService.writeFileRecursive(
-          import_node_path4.default.join(componentDir, `${lowerName}.handler.ts`),
+          import_node_path4.default.join(appDir, `${lowerName}.handler.ts`),
           handlerContent
         );
         const composableContent = `import { ref } from 'vue';
 import { AppError, Result, type ApiResponseDto, type ResultType } from '@xeno-js/vue';
 import { ServicesUtils } from '@/use-app';
-import { ${pascalName}Command } from './${lowerName}.command';
-import type { ${pascalName}Request, ${pascalName}Response } from './${lowerName}.model';
+import { ${pascalName}Command } from '../application/${lowerName}.command';
+import type { ${pascalName}Request, ${pascalName}Response } from '../domain/${lowerName}.model';
 
 /*
  * \u26A0\uFE0F WARNING: ACTION REQUIRED \u26A0\uFE0F
@@ -984,7 +1031,7 @@ export function use${pascalName}() {
 }
 `;
         await this._fileService.writeFileRecursive(
-          import_node_path4.default.join(componentDir, `use-${lowerName}.composable.ts`),
+          import_node_path4.default.join(presDir, `use-${lowerName}.composable.ts`),
           composableContent
         );
         const modelContent = `export interface ${pascalName}Request {
@@ -996,7 +1043,7 @@ export interface ${pascalName}Response {
 }
 `;
         await this._fileService.writeFileRecursive(
-          import_node_path4.default.join(componentDir, `${lowerName}.model.ts`),
+          import_node_path4.default.join(domainDir, `${lowerName}.model.ts`),
           modelContent
         );
       }
@@ -1020,6 +1067,9 @@ var init_generate_query_vue_generator = __esm({
       }
       _fileService;
       async generate(pascalName, lowerName, tokenPrefix, componentDir) {
+        const appDir = import_node_path5.default.join(componentDir, "application");
+        const domainDir = import_node_path5.default.join(componentDir, "domain");
+        const presDir = import_node_path5.default.join(componentDir, "presentation");
         const queryContent = `import { Query } from '@xeno-js/vue';
 import type { ${pascalName}Response } from './${lowerName}.model';
 
@@ -1036,13 +1086,13 @@ export class ${pascalName}Query extends Query<${pascalName}Response> {
 }
 `;
         await this._fileService.writeFileRecursive(
-          import_node_path5.default.join(componentDir, `${lowerName}.query.ts`),
+          import_node_path5.default.join(appDir, `${lowerName}.query.ts`),
           queryContent
         );
-        const handlerContent = `import type { IHandler, ResultType } from '@xeno-js/vue';
-import { AppError, Result } from '@xeno-js/vue';
+        const handlerContent = `import type { ResultType } from '@xeno-js/vue';
+import { AppError, BaseHandler, Result } from '@xeno-js/vue';
 import type { ${pascalName}Query } from './${lowerName}.query';
-import type { ${pascalName}Response } from './${lowerName}.model';
+import type { ${pascalName}Response } from '../domain/${lowerName}.model';
 
     /*
  * \u26A0\uFE0F WARNING: ACTION REQUIRED \u26A0\uFE0F
@@ -1057,28 +1107,26 @@ import type { ${pascalName}Response } from './${lowerName}.model';
  *     register('${tokenPrefix}_HANDLER', new ${pascalName}Handler());
  * });
  */
-export class ${pascalName}Handler implements IHandler<${pascalName}Query, ${pascalName}Response> {
+export class ${pascalName}Handler extends BaseHandler<${pascalName}Query, ${pascalName}Response> {
     constructor(
         // TODO: Inject your remote DataSources or other services here
     ) {}
 
-    public async handle(query: ${pascalName}Query, signal: AbortSignal): Promise<ResultType<${pascalName}Response>> {
-        AppError.throwIfAborted(signal, this.constructor.name);
-
+    protected async executeAsync(query: ${pascalName}Query, signal: AbortSignal): Promise<ResultType<${pascalName}Response>> {
         // TODO: Implement your frontend business logic or API calls here
         return Result.ok();
     }
 }
 `;
         await this._fileService.writeFileRecursive(
-          import_node_path5.default.join(componentDir, `${lowerName}.handler.ts`),
+          import_node_path5.default.join(appDir, `${lowerName}.handler.ts`),
           handlerContent
         );
         const composableContent = `import { ref } from 'vue';
 import { AppError, Result, type ApiResponseDto, type ResultType } from '@xeno-js/vue';
 import { ServicesUtils } from '@/use-app';
-import { ${pascalName}Query } from './${lowerName}.query';
-import type { ${pascalName}Response } from './${lowerName}.model';
+import { ${pascalName}Query } from '../application/${lowerName}.query';
+import type { ${pascalName}Response } from '../domain/${lowerName}.model';
 
 export function use${pascalName}() {
     const loading = ref(false);
@@ -1149,7 +1197,7 @@ const fetch = async (): Promise<ResultType<${pascalName}Response>> => {
 }
 `;
         await this._fileService.writeFileRecursive(
-          import_node_path5.default.join(componentDir, `use-${lowerName}.composable.ts`),
+          import_node_path5.default.join(presDir, `use-${lowerName}.composable.ts`),
           composableContent
         );
         const modelContent = `export interface ${pascalName}Response {
@@ -1157,7 +1205,7 @@ const fetch = async (): Promise<ResultType<${pascalName}Response>> => {
 }
 `;
         await this._fileService.writeFileRecursive(
-          import_node_path5.default.join(componentDir, `${lowerName}.model.ts`),
+          import_node_path5.default.join(domainDir, `${lowerName}.model.ts`),
           modelContent
         );
       }
@@ -1230,28 +1278,27 @@ var init_packagejson_generator = __esm({
           scripts: {
             dev: "vite",
             build: "vue-tsc -b && vite build",
-            preview: "vite preview",
-            g: "xeno-js generate"
+            preview: "vite preview"
           },
           dependencies: {
             "@xeno-js/vue": "latest",
-            "vue": "^3.5.0"
+            "vue": "^3.5.43"
           },
           devDependencies: {
             "@types/node": "^20.0.0",
             "@vitejs/plugin-vue": "^5.1.0",
-            "typescript": "^5.5.0",
+            "typescript": "^5.8.0",
             "vite": "^5.4.0",
-            "vue-tsc": "^2.1.0"
+            "vue-tsc": "^3.3.11"
           }
         };
-        if (options.axios) packageJson.dependencies["axios"] = "^1.7.0";
+        if (options.axios) packageJson.dependencies["axios"] = "^1.20.0";
         if (options.cockatiel) packageJson.dependencies["cockatiel"] = "^4.0.0";
-        if (options.supabase) packageJson.dependencies["@supabase/supabase-js"] = "^2.45.0";
-        if (options.sentry) packageJson.dependencies["@sentry/vue"] = "^8.28.0";
+        if (options.supabase) packageJson.dependencies["@supabase/supabase-js"] = "^2.117.1";
+        if (options.sentry) packageJson.dependencies["@sentry/vue"] = "^10.75.2";
         if (options.pinia) packageJson.dependencies["pinia"] = "^2.2.0";
-        if (options.router) packageJson.dependencies["vue-router"] = "^4.4.0";
-        if (options.zod) packageJson.dependencies["zod"] = "^4.4.3";
+        if (options.router) packageJson.dependencies["vue-router"] = "^4.6.4";
+        if (options.zod) packageJson.dependencies["zod"] = "^4.6.5";
         if (options.tailwind) {
           packageJson.devDependencies["tailwindcss"] = "^4.0.0";
           packageJson.devDependencies["@tailwindcss/vite"] = "^4.0.0";
@@ -1416,28 +1463,30 @@ var init_readme_generator = __esm({
         this._fileService = _fileService;
       }
       _fileService;
-      async generate(projectPath, options) {
-        const content = `# ${options.targetDir}
-
+      async generate(projectPath, _options) {
+        const content = `
 <div align="center">
-  <img src="logo/logo.png" alt="Xeno Logo" width="140" />
+  <img src="logo/logo.png" alt="Xeno Vue Logo" width="140" />
 
   <h1>Xeno Vue</h1>
 
-  <p><em>Enterprise-grade DDD & CQRS framework for Vue.js</em></p>
+  <p><strong>Your UI framework handles the UI. Xeno handles the application.</strong></p>
+
+  <p>
+    Application architecture for Vue with explicit dependency injection,
+    CQRS, composable pipelines, and clear boundaries between presentation,
+    application behavior, and infrastructure.
+  </p>
 
   <p>
-    <a href="https://github.com/xeno-js/xeno-js">
-      <img src="https://img.shields.io/badge/Powered%20by-Xeno-blueviolet?style=flat-square" alt="Powered by Xeno" />
-    </a>
-    <a href="https://github.com/xeno-js/xeno-fe/blob/main/LICENSE">
-      <img src="https://img.shields.io/npm/l/@xeno-js/vue?style=flat-square" alt="License: ISC" />
-    </a>
     <a href="https://www.npmjs.com/package/@xeno-js/vue">
-      <img src="https://img.shields.io/npm/v/@xeno-js/vue?style=flat-square" alt="NPM Version" />
+      <img src="https://img.shields.io/npm/v/@xeno-js/vue?style=flat-square" alt="npm version" />
     </a>
-    <a href="https://buymeacoffee.com/xenojs">
-      <img src="https://img.shields.io/badge/Buy%20Me%20A%20Coffee-Support-FFdd00?style=flat-square&logo=buy-me-a-coffee&logoColor=black" alt="Buy Me A Coffee" />
+    <a href="https://github.com/xeno-js/xeno-fe">
+      <img src="https://img.shields.io/github/stars/xeno-js/xeno-fe?style=flat-square" alt="GitHub stars" />
+    </a>
+    <a href="https://img.shields.io/npm/l/@xeno-js/vue?style=flat-square">
+      <img src="https://img.shields.io/npm/l/@xeno-js/vue?style=flat-square" alt="License: MIT" />
     </a>
   </p>
 </div>
@@ -1446,352 +1495,585 @@ var init_readme_generator = __esm({
 
 ## What is Xeno Vue?
 
-**Xeno Vue** (\`@xeno-js/vue\`) is an enterprise-grade, deterministic
-architectural framework that brings the strictness of **Domain-Driven Design
-(DDD)** and **Command Query Responsibility Segregation (CQRS)** natively to the
-browser.
+**Xeno Vue** (\`@xeno-js / vue\`) brings Xeno's application architecture to Vue applications.
+
+It provides the composition root and application building blocks needed to keep
+application behavior explicit instead of putting all of it inside Vue
+components.
+
+The package is built around:
+
+* explicit dependency injection;
+* a typed application registry;
+* commands and queries through a client-side mediator;
+* composable application pipelines;
+* remote data source boundaries;
+* browser request and identity context;
+* optional authentication, logging, validation, and caching integrations.
 
-By shifting operational logic, remote data fetching, and state mutations away
-from Vue components and Pinia stores, Xeno ensures your frontend architecture
-remains pristine, highly testable, and completely decoupled from the UI layer.
-It treats the browser as a complex distributed client, not just a document
-viewer.
+The goal is simple:
+
+> **Keep Vue responsible for presentation. Keep application behavior explicit.**
 
 ---
 
-## \u{1F4A1} Why Choose Xeno Vue?
-
-Modern frontend development often leads to "Spaghetti State" where API calls,
-business rules, and DOM manipulations are tightly coupled inside components.
-Xeno Vue fixes this with an emphasis on pure Dependency Injection (DI) and clean
-boundaries.
-
-- **Zero-Magic Dependency Injection**: Xeno provides an explicit
-  \`XenoAppBuilder\` to construct your IoC container at bootstrap. No hidden Vue
-  plugins doing implicit injections. You have total control over the dependency
-  graph.
-- **Total UI Decoupling**: Vue components act strictly as the Presentation
-  Layer. Business logic, API calls, and CQRS handlers live in pure, isolated
-  TypeScript classes. You can swap Vue for React tomorrow without touching your
-  core domain.
-- **Enterprise-Grade Client Resiliency**: The browser is a hostile, unreliable
-  environment. Xeno Vue natively integrates \`Cockatiel\` and \`Axios\` to provide
-  out-of-the-box circuit breakers, retries with jitter, and bulkheads directly
-  in the client.
-- **Frontend Middleware Pipeline**: Handle Authentication, CSRF validation,
-  aggressive Query Caching, and Performance logging _before_ a command is
-  executed or an API call fires, using the native \`Mediator\` pipeline.
+## The boundary
+
+A Vue application does not need to put every concern into components, stores, or router handlers.
+
+Xeno gives the application layer a distinct place to live:
+
+\`\`\`text
+Vue UI
+    \u2193
+    Application
+    \u2193
+    Domain / Shared
+    \u2193
+    Infrastructure
+    \u2193
+    HTTP / external systems
+      \`\`\`
+
+Vue remains your presentation layer.
+
+Xeno provides the application composition and execution model around it.
 
 ---
 
-## \u{1F4D6} Documentation & Getting Started
+## Why Xeno Vue?
+
+As an application grows, API calls, validation, logging, caching, authentication,
+and application decisions can end up spread across components.
+
+Xeno makes those responsibilities explicit.
+
+### Explicit dependency injection
+
+\`XenoAppBuilder\` is the composition root.
+
+Dependencies are registered in code instead of being discovered through decorators,
+runtime scanning, or hidden framework conventions.
 
-To explore the architecture, programmatic configurations, and extension
-workflows of Xeno Vue, read the full technical manuals located inside the main
-documentation hub:
+\`\`\`ts
+    import { XenoAppBuilder } from '@xeno-js/vue'
 
-- **[Framework Documentation Repository](https://www.xeno-js.it/vue/overview)**
+    const builder = XenoAppBuilder.create()
+      \`\`\`
 
-Inside, you will find exhaustive, step-by-step assembly guides covering frontend
-IoC building (\`XenoAppBuilder\`), Vue \`Provide/Inject\` boundaries, and CQRS
-composables.
+You configure the services your application needs through the builder.
 
 ---
 
-## \u{1F680} Live Executable Demos
+### CQRS in the browser
+
+The client mediator exposes two execution paths:
+
+\`\`\`text
+    Command
+   \u2193
+Command pipeline
+   \u2193
+Application action
+
+    Query
+   \u2193
+Query pipeline
+   \u2193
+Application action
+      \`\`\`
+
+Commands are sent with:
+
+\`\`\`ts
+    await services.mediator.send(command, action)
+      \`\`\`
 
-Want to see how Xeno Vue works? Check out the functional example application
-showcasing end-to-end command/query segregation, resilient HTTP fetching, and
-pure Composition API integration.
+Queries are executed with:
 
-- **[Xeno Vue Demo Architecture](https://www.xeno-js.it/demo)**
+\`\`\`ts
+    await services.mediator.query(query, action)
+      \`\`\`
+
+The application action is supplied by your code, so the transport remains behind
+an infrastructure boundary.
 
 ---
 
-## \u{1F4E6} Installation
+## Pipelines
 
-Install the Vue package:
+Cross-cutting behavior belongs in the application execution pipeline.
 
-\`\`\`bash
-npm install @xeno-js/vue
+The current implementation provides pipeline building blocks for:
 
-\`\`\`
+* exception handling;
+* logging;
+* performance thresholds;
+* validation with Zod schemas;
+* query caching.
 
-Xeno uses **Optional Peer Dependencies**. You only install the external
-libraries you actually need.
+Pipelines are composed by the application module and executed around commands
+and queries.
 
-\`\`\`bash
-# Example: Install tools only if you enable them in the builder
-npm install axios cockatiel zod @supabase/supabase-js @sentry/vue
+For example:
 
-\`\`\`
+\`\`\`ts
+    builder.addPipeline((config) => {
+      config.queryCaching = true
+      config.threshold = 500
+    })
+      \`\`\`
+
+Query caching uses the configured cache and is intended for query requests.
 
 ---
 
-## \u26A1 Bootstrapping & Component Example
+## Remote data sources
 
-Below is an architectural example of how to configure the Xeno \`XenoAppBuilder\`,
-inject it into the Vue application, and consume it using Composition API
-Composables.
+HTTP concerns can be isolated behind a remote data source.
 
-### 1. Initialize the Container (\`src/bootstrap.ts\`)
+\`\`\`ts
+    import { RemoteDataSource } from '@xeno-js/vue'
 
-\`\`\`typescript
-import { XenoAppBuilder, LOG_LEVEL, TOKENS } from '@xeno-js/vue'
-import { BffRemoteDataSource } from './infrastructure'
-
-import type { RemoteDataSource, XenoVueRegistry } from '@xeno-js/vue'
-
-export type MyRegistry = XenoVueRegistry<{
-  BFF_REMOTE_DS: RemoteDataSource
-}>
-
-// Create the root IoC container context for the browser
-const builder = XenoAppBuilder.create<MyRegistry>()
-  .addContext((opts) => {
-    opts.contextAccessor = useContextStore()
-  })
-  .addLogger((opts, config) => {
-    opts.console = config.get('VITE_APP_ENV') === 'development'
-    opts.level = LOG_LEVEL.DEBUG
-  })
-  .addAuth((opts, config) => {
-    opts.url = config.getOrThrow('VITE_SUPABASE_URL')
-    opts.key = config.getOrThrow('VITE_SUPABASE_KEY')
-  })
-  .addHttpCore('BFF_REMOTE_DS', (opts, config) => {
-    opts.client = {
-      baseURL: config.getOrThrow('VITE_API_BASE_URL'),
-      timeoutMs: 10000,
+    export class UsersRemoteDataSource extends RemoteDataSource {
+      public getById(id: string) {
+        return this.get<User>(\`/users/\${id}\`)
+      }
+
+      public create(payload: CreateUserPayload) {
+        return this.post<User, CreateUserPayload>('/users', payload)
+      }
     }
-    opts.resilience.retry.attempts = 3
-    opts.factory = (http, resilience) =>
-      new BffRemoteDataSource(http, resilience)
-  })
-  .addPipeline((config) => {
-    config.queryCaching = true // Enable in-memory caching for Queries
-  })
+    \`\`\`
 
-export async function bootstrap() {
-  return await builder.build()
-}
-\`\`\`
+The data source depends on the framework-neutral HTTP client abstraction.
 
-### 2. Inject into Vue (\`src/main.ts\`)
+\`XenoAppBuilder.addHttpCore()\` then provides the concrete HTTP client and registers
+the resulting data source in the application registry.
 
-\`\`\`typescript
-import { createApp } from 'vue'
-import App from './App.vue'
-import { bootstrap } from './bootstrap'
-import { XENO_SERVICES_KEY, ServicesUtils } from '@xeno-js/vue'
+\`\`\`ts
+    type AppRegistry = XenoVueRegistry<{
+      users: UsersRemoteDataSource
+    }>
 
-async function mountApp() {
-  try {
-    const app = createApp(App)
-    const container = await bootstrap()
+    const builder = XenoAppBuilder.create<AppRegistry>()
+      .addHttpCore('users', (config) => {
+        config.client.baseURL = '/api'
+        config.factory = (http) => new UsersRemoteDataSource(http)
+      })
+      \`\`\`
 
-    // Provide the Xeno IoC container globally to all components
-    app.provide(XENO_SERVICES_KEY, container)
+Axios is used by the built-in HTTP adapter when \`addHttpCore()\` is configured.
 
-    // Register global services utility for composables
-    ServicesUtils.setGlobalServices(container)
+---
 
-    app.mount('#app')
-  } catch (error) {
-    console.error('Critical error during frontend bootstrap:', error)
-  }
-}
+## Application context
 
-mountApp()
-\`\`\`
+Browser applications still need contextual information around the current
+execution.
 
-### 3. CQRS Composable Usage (\`src/features/users/use-create-user.ts\`)
+Xeno provides a browser context accessor containing information such as:
 
-\`\`\`typescript
-import { ref } from 'vue'
-import { Result } from '@xeno-js/shared'
-import { ServicesUtils } from '@/use-app'
-import { CreateUserCommand } from './create-user.command'
+* request ID;
+* correlation ID;
+* user identity;
+* user agent;
+* path;
+* origin;
+* transport metadata.
 
-export function useCreateUser() {
-  const loading = ref(false)
-  const error = ref<string | null>(null)
+You can use the default accessor or provide your own implementation.
 
-  const execute = async (payload: { email: string; name: string }) => {
-    if (loading.value) return Result.fail(new Error('Already executing'))
-    loading.value = true
-    error.value = null
+\`\`\`ts
+    builder.addContext((config) => {
+      // Optional custom context accessor configuration.
+    })
+      \`\`\`
 
-    try {
-      // Safely resolve the Mediator from the Xeno Container
-      const { mediator, BFF_REMOTE_DS } = ServicesUtils.useApp()
-      const command = new CreateUserCommand()
+---
 
-      const result = await mediator.send(command, async () => {
-        const apiResult = await bffRemoteDs.post('/v1/users', payload)
+## Logging
 
-        if (!apiResult.isOk()) return Result.fail(apiResult.getErrorOrThrow())
-        return Result.ok(apiResult.getValueOrThrow())
-      })
+Logging is configured independently from the application code.
+
+The package currently supports:
+
+* console logging;
+* Sentry logging;
+* custom logger clients.
+
+Example:
+
+\`\`\`ts
+    builder.addLogger((config) => {
+      config.console = true
+    })
+      \`\`\`
+
+Optional integrations are loaded when they are configured, keeping them outside
+the default bootstrap path.
+
+---
+
+## Authentication
+
+Supabase authentication is available as an infrastructure integration.
+
+\`\`\`ts
+    builder.addAuth((config, env) => {
+      config.url = env.getOrThrow('SUPABASE_URL')
+      config.key = env.getOrThrow('SUPABASE_KEY')
+    })
+      \`\`\`
+
+The default configuration service resolves \`VITE_\` environment variables in
+Vite applications.
+
+For example:
+
+\`\`\`text
+    VITE_SUPABASE_URL
+    VITE_SUPABASE_KEY
+      \`\`\`
 
-      if (!result.isOk()) {
-        error.value = result.getErrorOrThrow().message
+Authentication is an integration, not part of the application's business rules.
+
+---
+
+## Validation
+
+Application request validation can be configured with Zod schemas.
+
+\`\`\`ts
+    builder.addPipeline((config) => {
+      config.schemas = {
+        CreateUser: createUserSchema,
+        UpdateUser: updateUserSchema,
       }
+    })
+      \`\`\`
+
+Validation is executed as part of the application pipeline.
+
+Zod remains optional until validation schemas are actually configured.
+
+---
+
+## Query caching
+
+The package includes an in-memory cache path for query requests.
+
+Enable it through the pipeline configuration:
+
+\`\`\`ts
+    builder.addPipeline((config) => {
+      config.queryCaching = true
+    })
+      \`\`\`
+
+Cache keys can be contextual or user-scoped through the shared cache key builder.
+
+---
+
+## Bootstrap
+
+A complete browser composition root can look like this:
+
+\`\`\`ts
+    import { XenoAppBuilder } from '@xeno-js/vue'
+
+    const builder = XenoAppBuilder.create()
+      .addContext(() => { })
+      .addLogger((config) => {
+        config.console = true
+      })
+      .addAuth((config, env) => {
+        config.url = env.getOrThrow('SUPABASE_URL')
+        config.key = env.getOrThrow('SUPABASE_KEY')
+      })
+      .addPipeline((config) => {
+        config.queryCaching = true
+        config.threshold = 500
+      })
 
-      return result
-    } finally {
-      loading.value = false
+    export async function bootstrap() {
+      return builder.build()
     }
-  }
+    \`\`\`
 
-  return { loading, error, execute }
-}
-\`\`\`
+The builder executes the registered tasks and returns a frozen application
+registry.
+
+The composition root is application code: there is no requirement to hide it
+behind Vue plugins or decorators.
 
 ---
 
-## \u{1F6E0} Scaffold your project with CLI
+## Providing services to Vue
 
-Xeno includes an official CLI tool, \`@xeno-js/cli\`, designed to bootstrap your
-new application in seconds. It offers an interactive setup for Vue projects,
-instantly scaffolding the CQRS files, composables, and dependency injection
-boundaries.
+The package exports \`XENO_SERVICES_KEY\` so the application registry can be made
+available through Vue's \`provide / inject\` mechanism.
 
-\`\`\`bash
-# Generate a new Vue project
-npx @xeno-js/cli new my-frontend-app --vue
+\`\`\`ts
+    import { createApp } from 'vue'
+    import { XENO_SERVICES_KEY } from '@xeno-js/vue'
 
-# Generate a Vue Command with its Composable
-npx @xeno-js/cli g command CreateUser --vue
+    import App from './App.vue'
+    import { bootstrap } from './bootstrap'
 
-\`\`\`
+    async function mountApp() {
+      const app = createApp(App)
+      const services = await bootstrap()
+
+      app.provide(XENO_SERVICES_KEY, services)
+      app.mount('#app')
+    }
+
+    mountApp()
+      \`\`\`
+
+From there, your application code can resolve the registry through Vue's normal
+dependency injection mechanism.
+
+The package does not require a custom state-management abstraction.
+
+---
+
+## Keeping application logic outside components
+
+A component can remain focused on presentation while application behavior lives
+in a composable or application service written by your project.
+
+For example:
+
+\`\`\`ts
+    import { inject } from 'vue'
+    import { XENO_SERVICES_KEY } from '@xeno-js/vue'
+
+    export function useUsersApplication() {
+      const services = inject(XENO_SERVICES_KEY)
+
+      if (!services) {
+        throw new Error('Xeno services are not available')
+      }
+
+      return services
+    }
+    \`\`\`
 
-Check the
-**[CLI Documentation](https://www.google.com/search?q=https://www.xeno-js.it/cli/overview&utm_source=gemini)**
-for full options.
+The composable belongs to your application.
+
+Xeno provides the application infrastructure it uses.
 
 ---
 
-## \u{1F91D} For Contributors
+## Public API
+
+The package root currently exposes:
+
+\`\`\`text
+    XenoAppBuilder
+    RemoteDataSource
+    XENO_SERVICES_KEY
+      \`\`\`
 
-We welcome contributions to Xeno! To maintain the highest code quality and
-stability of the core framework, **direct pushes to the \`main\` and \`develop\`
-branches are strictly prohibited.** Please follow this Git Flow to contribute:
+It also re-exports the public contracts and primitives from \`@xeno-js / shared\`.
 
-1. **Branch off from \`develop**\`: Create a new branch for your feature or
-   bugfix.
+The concrete internal pipeline implementations are assembled by the builder and
+are not intended to be the primary public API of the package.
+
+---
+
+## Installation
+
+Install Vue, Shared, and Xeno Vue:
 
 \`\`\`bash
-git checkout develop
-git pull origin develop
-git checkout -b feat/your-awesome-feature
+npm install @xeno-js / vue @xeno-js / shared vue
+      \`\`\`
 
-\`\`\`
+Install the integrations you actually use.
 
-2. **Make your changes**: Write your code and ensure it passes all local checks
-   (linting, types, and tests).
+For HTTP data sources:
 
 \`\`\`bash
-npm run check
+npm install axios
+      \`\`\`
 
-\`\`\`
+For validation:
+
+\`\`\`bash
+npm install zod
+      \`\`\`
+
+For Supabase authentication:
+
+\`\`\`bash
+npm install @supabase/supabase-js
+      \`\`\`
+
+For Sentry:
+
+\`\`\`bash
+npm install @sentry/vue
+      \`\`\`
 
-3. **Commit your changes**: We enforce
-   [Conventional Commits](https://www.conventionalcommits.org/?utm_source=gemini).
-   Husky will verify your commit message format.
-4. **Commit Format:**
+For Vue Router integration:
 
 \`\`\`bash
-feat(scope): add new feature
-fix(scope): resolve bug
-chore(scope): update dependencies
+npm install vue - router
+      \`\`\`
+
+---
+
+## CLI
+
+The Xeno ecosystem includes an official CLI for creating Vue application
+structures:
+
+\`\`\`bash
+npx @xeno-js / cli new my - app--vue
+      \`\`\`
+
+You can also generate application components inside an existing project:
+
+\`\`\`bash
+npx @xeno-js / cli g command CreateUser--vue
+      \`\`\`
+
+CLI:
 
+https://github.com/xeno-js/xeno-cli
+
+---
+
+## Xeno ecosystem
+
+\`\`\`text
+    @xeno-js / shared
+    Define the application.
+
+@xeno-js / core
+    Execute the backend application.
+
+@xeno-js / vue
+    Bring the application architecture to Vue.
+
+@xeno-js / cli
+    Get started with the structure.
 \`\`\`
 
-5. **Submit a Pull Request (PR)**: Push your branch to GitHub and open a Pull
-   Request targeting the **\`develop\`** branch.
-6. **Review**: The repository owner will review your code, run pipeline tests,
-   and merge it into \`develop\`.
+A useful mental model is:
+
+\`\`\`text
+    Transport
+    hosts the application
+
+    Application
+    executes use cases
+
+    Domain
+    defines business rules
+
+    Infrastructure
+    connects external systems
+      \`\`\`
 
-_Note: The \`main\` branch is strictly reserved for production releases. Code
-flows from feature branches \u27A1\uFE0F \`develop\` \u27A1\uFE0F \`main\`._
+---
 
-### Scripts
+## Keep your stack
 
-| Command                 | Description                                    |
-| ----------------------- | ---------------------------------------------- |
-| \`npm run build\`         | Builds the TypeScript source code into \`dist/\` |
-| \`npm run typecheck\`     | Checks types without emitting files            |
-| \`npm run lint\`          | Runs ESLint                                    |
-| \`npm run format\`        | Formats code with Prettier                     |
-| \`npm run test\`          | Runs the Vitest test suite                     |
-| \`npm run test:coverage\` | Runs tests and generates a coverage report     |
+Xeno Vue does not replace Vue.
 
-### Code Quality (Husky & Git Hooks)
+It does not replace your router.
 
-This project strictly enforces code quality rules before pushing to the
-repository:
+It does not replace your state management solution.
 
-- **\`pre-commit\`**: Runs \`lint-staged\` on staged files (ESLint + Prettier).
-- **\`commit-msg\`**: Checks commit messages with \`commitlint\` (we use
-  Conventional Commits).
-- **\`pre-push\`**: Runs type checking, linting, and testing before code leaves
-  your machine.
+It provides a place for application behavior and infrastructure composition to
+live alongside the tools you already use.
 
 ---
 
-## \u{1F331} Support & Appreciation
+## Browser environment
+
+The default configuration service is designed for Vite/browser applications.
+
+The package provides browser-oriented request context data and integrates with
+Vue's dependency injection system.
+
+Node.js \`20 + \` is required by the package tooling.
+
+---
 
-Building, benchmarking, and maintaining a progressive, enterprise-ready
-open-source framework requires a massive amount of continuous dedication and
-architectural engineering.
+## Development
 
-If Xeno has brought value to your development workflows, helped decouple your
-core business logic, or simplified your system infrastructure layout, consider
-supporting its open-source lifecycle. Your backing directly accelerates our
-strategic roadmap for new out-of-the-box transport integrations and keeps the
-documentation pristine.
+Clone the repository:
 
-**Want to know how you can contribute or sponsor Xeno?** We rely on the
-commitment of our community to keep the project independent and thriving.
-Whether you are an individual developer or a business using Xeno, your support
-makes a real difference.
+\`\`\`bash
+git clone https://github.com/xeno-js/xeno-fe.git
+cd xeno - fe
+npm install
+      \`\`\`
+
+Run the checks:
+
+\`\`\`bash
+npm run check
+      \`\`\`
 
-\u{1F449}
-**[Read our support guidelines and find out how to help](https://www.xeno-js.it/support-us)**
+Useful commands:
 
-Thank you for being part of this decoupled open-source journey!
+\`\`\`bash
+npm run build
+npm run typecheck
+npm run lint
+npm run test
+npm run test: coverage
+npm run format
+      \`\`\`
 
-<amp-bounce>
-</amp-bounce>
-<a href="https://www.buymeacoffee.com/xenojs" target="_blank">
-<img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me A Coffee" height="42" style="height: 42px !important;" />
-</a>
+Development happens from feature branches targeting \`develop\`.
 
 ---
 
-## \u{1F6E1}\uFE0F Powered by Xeno
-
-If you are using Xeno in your project, let the world know! Add this badge to
-your README:
-
-\`\`\`html
-<a
-  href="[https://github.com/xeno-js/xeno-fe](https://github.com/xeno-js/xeno-fe)"
-  target="_blank"
->
-  <img
-    src="[https://img.shields.io/badge/Powered%20by-Xeno-black?style=flat-square](https://img.shields.io/badge/Powered%20by-Xeno-black?style=flat-square)"
-    alt="Powered by Xeno"
-    height="20"
-  />
-</a>
-\`\`\`
+## Contributing
+
+Contributions are welcome.
+
+Create a feature branch from \`develop\`:
+
+\`\`\`bash
+git checkout develop
+git pull origin develop
+git checkout - b feat / your - feature
+      \`\`\`
+
+Run the project checks before opening a pull request:
+
+\`\`\`bash
+npm run check
+      \`\`\`
+
+We use Conventional Commits:
+
+\`\`\`text
+    feat(vue): add application service
+    fix(datasource): correct request handling
+    refactor(builder): simplify bootstrap
+    docs(readme): clarify architecture
+      \`\`\`
 
-## \u{1F4C4} License
+Open pull requests against:
+
+\`\`\`text
+    develop
+      \`\`\`
+
+---
 
-Copyright (c) 2026 Xeno. Licensed under the
-[ISC License](https://www.google.com/search?q=LICENSE&utm_source=gemini).
+## License
+
+MIT License. See \`LICENSE\`.
 `;
         await this._fileService.writeFileRecursive(import_node_path12.default.join(projectPath, "README.md"), content);
       }
@@ -1925,7 +2207,7 @@ var init_bootstrap_ts_generator = __esm({
         if (options.sentry) {
           builderNodes += `
     .addLogger((opts, config) => {
-      const env = config.get(COMMON_CONSTANTS.ENV) ?? 'development'
+      const env = config.get('APP_ENV') ?? 'development'
       const isDev = env.toLowerCase() === 'development'
       opts.console = isDev
       if (!isDev) {
@@ -2320,8 +2602,7 @@ var init_packagejson_generator2 = __esm({
           types: "./dist/index.d.ts",
           scripts: {
             start: "tsx src/main.ts",
-            build: "tsc --project tsconfig.json",
-            g: "xeno-js generate"
+            build: "tsc --project tsconfig.json"
           },
           dependencies: {
             "@xeno-js/core": "latest",
@@ -2330,35 +2611,35 @@ var init_packagejson_generator2 = __esm({
           devDependencies: {
             "@types/node": "^20.0.0",
             "tsx": "^4.7.0",
-            "typescript": "^5.4.0"
+            "typescript": "^5.8.0"
           }
         };
         if (options.database !== CORE_CONSTANTS.NONE) {
-          if (options.database === CORE_CONSTANTS.DRIZZLE) {
-            packageJson.dependencies["drizzle-orm"] = "^0.45.2";
-            packageJson.dependencies["pg"] = "^8.22.0";
-            packageJson.dependencies["postgres"] = "^3.4.9";
-            packageJson.devDependencies["@types/pg"] = "^8.11.0";
-            packageJson.devDependencies["drizzle-kit"] = "^0.31.10";
-            packageJson.scripts["db:migrate"] = "drizzle-kit migrate";
-          } else if (options.database === CORE_CONSTANTS.SQL_LITE) {
-            packageJson.dependencies["drizzle-orm"] = "^0.45.2";
-            packageJson.dependencies["@libsql/client"] = "^0.14.0";
-            packageJson.devDependencies["drizzle-kit"] = "^0.31.10";
-          }
+          packageJson.dependencies["drizzle-orm"] = "^0.45.3";
+          packageJson.dependencies["pg"] = "^8.23.0";
+          packageJson.dependencies["postgres"] = "^3.4.9";
+          packageJson.devDependencies["@types/pg"] = "^8.23.1";
+          packageJson.devDependencies["drizzle-kit"] = "^0.31.11";
+          packageJson.scripts["db:migrate"] = "drizzle-kit migrate";
+          packageJson.dependencies["drizzle-orm"] = "^0.45.3";
+          packageJson.devDependencies["drizzle-kit"] = "^0.31.11";
+          packageJson.dependencies["@libsql/client"] = "^0.14.0";
           packageJson.scripts["db:generate"] = "drizzle-kit generate";
           packageJson.scripts["db:push"] = "drizzle-kit push";
         }
-        if (options.axios) packageJson.dependencies["axios"] = "^1.16.1";
+        if (options.axios) packageJson.dependencies["axios"] = "^1.20.0";
         if (options.cockatiel) packageJson.dependencies["cockatiel"] = "^4.0.0";
         if (options.pino) {
           packageJson.dependencies["pino"] = "^10.3.1";
           packageJson.devDependencies["pino-pretty"] = "^11.2.2";
         }
-        if (options.sentry) packageJson.dependencies["@sentry/node"] = "^7.64.0";
-        if (options.redis) packageJson.dependencies["ioredis"] = "^5.3.1";
-        if (options.supabase) packageJson.dependencies["@supabase/supabase-js"] = "^2.35.0";
-        if (options.zod) packageJson.dependencies["zod"] = "^4.4.3";
+        if (options.sentry) packageJson.dependencies["@sentry/node"] = "^11.0.0";
+        if (options.redis) packageJson.dependencies["ioredis"] = "^6.0.0";
+        if (options.supabase) {
+          packageJson.dependencies["@supabase/supabase-js"] = "^2.117.1";
+          packageJson.dependencies["@supabase/ssr"] = "^0.12.7";
+        }
+        if (options.zod) packageJson.dependencies["zod"] = "^4.6.5";
         const filePath = import_node_path22.default.join(projectPath, "package.json");
         await this._fileService.writeFileRecursive(filePath, JSON.stringify(packageJson, null, 2));
       }
@@ -2572,23 +2853,17 @@ var init_readme_generator2 = __esm({
       _fileService;
       async generate(projectPath, _options) {
         const content = `
-        <div align="center">
+<div align="center">
   <img src="logo/logo.png" alt="Xeno Logo" width="140" />
 
-  <h1>Xeno</h1>
-
-  <p><em>Enterprise-grade DDD & CQRS framework for Node.js</em></p>
+  <h1>Xeno.JS</h1>
+  <p><strong>The application architecture framework for TypeScript.</strong></p>
+  <p>Build long-lived applications with explicit dependency injection, DDD, CQRS, and transport-independent business logic.</p>
 
   <p>
-    <a href="https://github.com/xeno-js/xeno-js">
-      <img src="https://img.shields.io/badge/Powered%20by-Xeno-blueviolet?style=flat-square" alt="Powered by Xeno" />
-    </a>
-    <a href="https://github.com/xeno-js/xeno-js/blob/main/LICENSE">
-      <img src="https://img.shields.io/npm/l/@xeno?style=flat-square" alt="License: ISC" />
-    </a>
-    <a href="https://www.npmjs.com/package/@xeno/core">
-      <img src="https://img.shields.io/npm/v/@xeno/core?style=flat-square" alt="NPM Version" />
-    </a>
+    <a href="https://www.npmjs.com/package/@xeno-js/core"><img src="https://img.shields.io/npm/v/@xeno-js/core?style=flat-square" alt="NPM Version" /></a>
+    <a href="https://github.com/xeno-js/xeno-js"><img src="https://img.shields.io/badge/Powered%20by-Xeno-blueviolet?style=flat-square" alt="Powered by Xeno" /></a>
+    <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue?style=flat-square" alt="License: MIT" /></a>
     <a href="https://buymeacoffee.com/xenojs">
       <img src="https://img.shields.io/badge/Buy%20Me%20A%20Coffee-Support-FFdd00?style=flat-square&logo=buy-me-a-coffee&logoColor=black" alt="Buy Me A Coffee" />
     </a>
@@ -2599,391 +2874,443 @@ var init_readme_generator2 = __esm({
 
 ## What is Xeno?
 
-**Xeno** is an enterprise-grade, runtime-agnostic architectural framework for
-Node.js built natively with TypeScript. It provides structural primitives for
-implementing robust **Domain-Driven Design (DDD)** and **Command Query
-Responsibility Segregation (CQRS)** patterns. By shifting operational logic away
-from delivery mechanisms and transport frameworks, Xeno ensures your core
-application architecture remains pristine, testable, and completely isolated
-from external infrastructural churn.
+Xeno is a TypeScript application architecture framework for Node.js.
 
----
+It provides explicit building blocks for applications organized around:
+
+- **Dependency Injection** with explicit service registration and lifetimes
+- **Domain-Driven Design (DDD)** and domain/application boundaries
+- **CQRS** with commands, queries, handlers, and composable pipelines
+- **Request context** built around asynchronous execution context
+- **Repositories and data sources** that keep persistence behind application
+  boundaries
+- **Infrastructure adapters** for databases, Redis, authentication, logging,
+  resilience, and other integrations
+
+The goal is simple: **make application architecture explicit in code.**
 
-## \u{1F4A1} Why Choose Xeno?
-
-Modern Node.js frameworks often tie business workflows tightly to HTTP server
-abstractions or rely heavily on experimental language features. Xeno fixes this
-with an emphasis on developer experience, type safety, and clean separation of
-concerns.
-
-- **Zero Decorators**: Xeno eliminates reliance on experimental or unstable TS
-  decorator specifications (\`reflect-metadata\`). The IoC container
-  (\`ServiceContainer\`) uses pure, explicit functional factories that optimize
-  compilation speeds and eliminate runtime black-box behaviors.
-- **Complete Server Decoupling**: Xeno does not care if you use Fastify, Hono,
-  Express, Koa, or AWS Lambda. The presentation layer handles incoming data
-  using plain, primitive contracts, making migration or multi-runtime hosting
-  completely seamless.
-- **Pay-For-What-You-Use (Opt-in Modularity)**: Core dependencies are
-  strategically classified as optional peer dependencies. If your architecture
-  doesn't use Redis, Sentry, or Supabase, you do not pull them into your node
-  modules.
-- **Enterprise-Grade Resiliency & Cross-Cutting Pipelines**: Address complex
-  distributed patterns natively without code duplication. Xeno provides
-  out-of-the-box composite behaviors:
-  - **Idempotency**: Implements multi-tenant logic keyspaces matching advanced
-    SaaS factory patterns for logical partitioning.
-  - **Concurrency Control**: Mitigates thundering herd impacts via advanced
-    backoff retry strategies coupled with randomized jitter.
-  - **Resilience Policies**: Deep integration with circuit breakers, bulkheads,
-    and fallbacks.
-  - **Deterministic Type Safety**: Strong infrastructure validation strategies
-    using Zod schemas.
+Xeno is not tied to a specific HTTP server. Your application layer can remain
+independent from the transport that delivers a request.
 
 ---
 
-## \u{1F4D6} Documentation & Getting Started
+## Why Xeno?
 
-To explore the architecture, programmatic configurations, and extension
-workflows of Xeno, read the full technical manuals located inside the main
-documentation hub:
+### 01 \u2014 Explicit Architecture
 
-- **[Framework Documentation Repository](https://www.xeno-js.it/introduction)**
+**Your dependency graph is code.**
 
-Inside, you will find exhaustive, step-by-step assembly guides covering core
-host building (\`AppBuilder\`), isolated request middleware lifecycles, functional
-\`Result\` monads, and zero-trust authorization pipeline behavior tracks.
+Xeno does not require decorators, runtime scanning, or implicit dependency
+discovery. Services are registered explicitly, and their lifetimes are visible
+at the composition root.
 
----
+\`\`\`typescript
+    services.addScoped('USER_REPOSITORY', (container) => {
+      return new UserRepository(
+        container.resolve('USER_DATA_SOURCE'),
+        container.resolve('USER_MAPPER'),
+      )
+    })
+      \`\`\`
+
+This makes the composition of the application easier to inspect, test, and
+reason about.
+
+### 02 \u2014 Transport Independence
+
+Business logic should not belong to your HTTP framework.
+
+Xeno keeps application concerns separate from delivery mechanisms, allowing the
+same application architecture to be hosted behind transports such as Fastify,
+Hono, Express, or other adapters.
+
+\`\`\`text
+    HTTP / CLI / Worker / Lambda
+      |
+      v
+    Presentation
+      |
+      v
+    Application
+    Commands / Queries
+      |
+      v
+    Domain
+      |
+      v
+    Infrastructure
+    DB / Redis / APIs
+      \`\`\`
+
+### 03 \u2014 CQRS as an Application Primitive
+
+Commands and queries are first-class application concepts.
+
+Pipelines can compose cross-cutting behavior around execution, such as:
+
+- authorization
+- idempotency
+- concurrency control
+- caching
+- resilience policies
+- request context
+
+This keeps cross-cutting concerns out of individual handlers.
 
-## \u{1F680} Live Executable Demos
+### 04 \u2014 Explicit Lifetimes and Request Boundaries
 
-Want to see how Xeno works? Check out the functional example application
-showcasing end-to-end command/query segregation, multi-tenant databases, and
-resilient schema handling.
+Xeno distinguishes service lifetimes such as singleton, scoped, and transient
+services.
 
-You can dive straight into the explicit source code modules of specialized
-sandbox environments:
+Request-scoped dependencies are resolved inside an explicit application scope,
+while request metadata can be carried through asynchronous execution using
+\`AsyncLocalStorage\`.
 
-- **[\`pipelines_middleware_demo/\`](https://www.xeno-js.it/demo)**: Traces
-  an execution thread from the raw HTTP transport presentation layer, executing
-  automated header extraction and anchoring metadata variables into
-  \`AsyncLocalStorage\` thread boundaries.
+Database transaction state is scoped to the same application boundary, allowing
+\`UnitOfWork\` and \`DbContext\` to operate against the transaction associated with
+the current scope.
+
+### 05 \u2014 Infrastructure Stays Outside the Domain
+
+Database clients, Redis, HTTP clients, authentication providers, loggers, and
+other infrastructure integrations are composed at the edge of the application.
+
+Your domain and application code can depend on contracts instead of concrete
+infrastructure.
 
 ---
 
-## \u{1F4E6} Installation
+## Architecture
+
+A typical Xeno application can be organized like this:
+
+\`\`\`text
+      + ------------------------------------------+
+| Presentation |
+| HTTP / CLI / Workers / Lambda |
+        +--------------------- +--------------------+
+                      |
+          v
+          + ------------------------------------------+
+| Application |
+| Commands / Queries / Handlers / Pipes |
+            +--------------------- +--------------------+
+                      |
+              v
+              + ------------------------------------------+
+| Domain |
+| Entities / Policies / Rules |
+                +--------------------- +--------------------+
+                      |
+                  v
+                  + ------------------------------------------+
+| Infrastructure |
+| DB / Redis / APIs / Auth / Logs |
+                    +------------------------------------------+
+                      \`\`\`
+
+Xeno's core is focused on composition and application architecture.
+Infrastructure capabilities can be enabled only when they are needed.
 
-Install the core package:
+---
 
-\`\`\`bash
-npm install @xeno-js/core
+## Core Concepts
 
-\`\`\`
+| Concept            | Purpose                                                   |
+| ------------------ | --------------------------------------------------------- |
+| \`AppBuilder\`       | Composition root for assembling an application            |
+| \`ServiceContainer\` | Explicit dependency injection and service lifetimes       |
+| \`CQRS\`             | Commands, queries, handlers, and mediator-based execution |
+| \`Pipelines\`        | Cross-cutting behavior around application execution       |
+| \`Request Context\`  | Request metadata across asynchronous execution            |
+| \`Repository\`       | Application-facing persistence abstraction                |
+| \`DataSource\`       | Infrastructure-facing data access implementation          |
+| \`Module\`           | Explicit registration of related capabilities             |
+| \`Result\`           | Typed success/failure flow for application operations     |
 
-Xeno uses **Optional Peer Dependencies**. You only install the external
-libraries you actually need. Node.js will strictly lazy-load only the modules
-you enable in the configuration.
+---
+
+## Installation
 
 \`\`\`bash
-# Example: Install tools only if you enable them in the builder
-npm install zod pino cockatiel drizzle-orm
+npm install @xeno-js / core
+      \`\`\`
 
-\`\`\`
+Install only the integrations your application uses. Xeno exposes optional
+infrastructure dependencies for capabilities such as databases, Redis, logging,
+resilience, and authentication.
 
----
+For example:
+
+\`\`\`bash
+npm install zod pino cockatiel drizzle - orm
+      \`\`\`
 
-## \u26A1 Bootstrapping & Middleware Example
+---
 
-Below is an architectural example of how to configure the Xeno
-\`ServiceContainer\`, load core modules, and process an incoming application
-payload natively inside a server middleware wrapper.
+## A Small Example
 
-### 1. Initialize the Container and Configure Modules
+The composition root is explicit:
 
 \`\`\`typescript
-import { AppBuilder, LOG_LEVEL, TOKENS, XenoRegistry } from '@xeno-js/core'
-import { FindUserQueryHandler } from './user/cqrs/handlers/index'
-import { FindUserController } from './user/controllers/index'
-import { UserMapper } from './user/mappers/user.mapper'
-import { UserWriteRepository } from './user/repositories/user-write.repository'
-import { UserDataSource } from './user/datasources/user.datasource'
-
-// Map your registry token with XenoRegistry<TSchemaDb, TExtension>
-type MyRegistry = XenoRegistry<{ /** Your Db Schema here **/}, {
-  USER_MAPPER_TOKEN: UserMapper
-  USER_DS_TOKEN: UserDataSource
-  USER_REPOSITORY_TOKEN: UserWriteRepository
-  FIND_USER_QUERY_HANDLER_TOKEN: FindUserQueryHandler
-  FIND_USER_CONTROLLER_TOKEN: FindUserController
-}>
-
-// Create the root IoC container context
-export const bootstrap = new AppBuilder<MyRegistry>()
-        // Configure middleware and only PUBLIC routes
-        .addMiddlewares(opts => {
-            opts.routeRegistry = {
-                '/api/user/:id': ['GET', 'POST'],
-            }
-        })
-        // Configure the CQRS pipeline
-            // Can register Policies for your intent
-              .addPipeline((config) => {
-                config.authorization.policies = {
-                  'FIND_USER_QUERY_HANDLER_TOKEN': {
-                    // Add authz by user id
-                    userId: true
-                    // Add authz by tenant id
-                    tenantId: true
-                    // Add authz by roles
-                    roles: ['admin']
-                    // Add authz by perissions
-                    permissions: ['read'],
-                }
-            }
-            // Can add idempotency pipeline for command
-            config.commandBus.idempotency = { lockTtlSeconds: 30, processedTtlSeconds: 60 }
-            // Can add concurrency pipeline for command
-            config.commandBus.concurrency = { delayConfig: { baseDelayMs: 100, maxJitterMs: 500 }, maxRetries: 3 }
-            // Can add caching pipeline for query
-            config.queryBus.isEnabled = true
-        })
-        // Configure Database with drizzle
-        .addDb((opts, config) => {
-            opts.connectionString = config.getOrThrow('DATABASE_URL')
-        })
-        // Configure Authentication with supabase
-        .addAuth((opts, config) => {
-            opts.key = 'demo-key'
-            opts.url = config.getOrThrow('API_BASE_URL')
+    // src/bootstrap.ts
+    import { AppBuilder } from '@xeno-js/core'
+
+    const app = new AppBuilder()
+      .addServices((services) => {
+        services.addScoped('USER_REPOSITORY', (container) => {
+          return new UserRepository(container.resolve('USER_DATA_SOURCE'))
         })
-        // Configure your logger (e.g. Console, Sentry, Pino or custom logger)
-        .addLogger((config) => {
-            config.level = LOG_LEVEL.INFO
-            config.console = true
+
+        services.addScoped('FIND_USER_HANDLER', (container) => {
+          return new FindUserHandler(container.resolve('USER_REPOSITORY'))
         })
-        // Register your services
-        .addServices((services) => {
-            // REGISTER MAPPER
-            services.addScoped('USER_MAPPER_TOKEN', () => new UserMapper())
-
-            // REGISTER DATASOURCES
-            services.addScoped('USER_DS_TOKEN', (c) => new UserDataSource(c.resolve(TOKENS.DB_CONTEXT)))
-
-            // REGISTER REPOSITORIES
-            services.addScoped('USER_REPOSITORY_TOKEN', (c) => new UserWriteRepository(c.resolve('USER_DS_TOKEN'), c.resolve('USER_MAPPER_TOKEN')))
-
-            // REGISTER HANDLERS
-            services.addScoped('FIND_USER_QUERY_HANDLER_TOKEN', (c) => {
-                const requestcontext = c.resolve('USER_CONTEXT_FACTORY')
-                const repository = c.resolve('USER_READ_REPOSITORY')
-                return new FindUserQueryHandler(repository, requestcontext)
-            })
-
-            // REGISTER CONTROLLERS
-            services.addTransient('FIND_USER_CONTROLLER_TOKEN', (c) => {
-                return new FindUserController(c.resolve('CONTEXT_ACCESSOR'), c.resolve('MEDIATOR'))
-            })
+
+        services.addTransient('FIND_USER_CONTROLLER', (c) => {
+          return new FindUserController(
+            c.resolve(TOKENS.REQUEST_CONTEXT),
+            c.resolve(TOKENS.MEDIATOR),
+          )
         })
+      })
 
-\`\`\`
+    await app.build()
+      \`\`\`
+
+The transport remains outside the application composition:
 
-### 2. Wrap and Run within Server Middleware (e.g., Fastify / Hono)
+> \u26A0\uFE0F **Implementation note: Example using Fastify** The following snippet uses
+> **Fastify** solely for demonstration purposes to illustrate the transport
+> layer. Thanks to the framework's agnostic architecture, the underlying logic
+> (\`container\` and \`handler\`) remains unchanged regardless of the chosen HTTP
+> system (e.g., Express, Koa) or interface (CLI, gRPC).
 
 \`\`\`typescript
-import 'dotenv/config'
-import { ContainerUtils } from '@xeno-js/core'
-import fastify from 'fastify'
-import { bootstrap } from './bootstrap'
+    import Fastify from 'fastify'
+    import { app } from './bootstrap'
 
-async function runDemo() {
-  console.log('\u2699\uFE0F Initialized Xeno Container...')
-  try {
-    // 1. Bootstrap the application and get the service container
-    const xenoApp = await bootstrap.build()
-
-    console.log('\u{1F680} Starting Fastify server on http://localhost:3000...')
-
-    // 2. Resolve the middleware from the container
-    const middleware = xeno.resolve('MIDDLEWARE')
-    // 3. Create a Fastify instance to handle HTTP requests
-    const app = fastify()
-
-    // \u2500\u2500\u2500 ENDPOINT 2: QUERY \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
-    app.get('/api/user/:id', async (request, reply) => {
-      // 4. Execute the middleware to handle the request context and authentication, then call the StatusController's handle method with the request payload.
-      const responseDto = await middleware.execute(
-            { path: '/api/user/:id', method: 'GET', transport: { res: reply, req: request } },
-            { ...request.headers },
-            async () => {
-                const { id } = request.params as any
-                const controller = ContainerUtils.resolveServiceScoped('FIND_USER_CONTROLLER_TOKEN', xenoApp)
-                return await controller.handle({ id: id ?? '123' });
-            }
-        );
+    const fastify = Fastify({ logger: true })
 
-      return reply
-        .status(responseDto.status)
-        .type('application/json')
-        .send(responseDto.data)
-    })
+    fastify.get('/users/:id', async (req, reply) => {
+      const endpoint = req.url
 
-    console.log('\u2705 Routes set up. Ready to accept requests.')
+      const action = async () => {
+        const controller = ContainerUtils.resolveServiceScoped(
+          'FIND_USER_CONTROLLER',
+          app,
+        )
+        return await controller.handle()
+      }
 
-    // \u2500\u2500\u2500 START SERVER \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
-    try {
-      await app.listen({ port: 3000 })
-      console.log('\u{1F680} Application running on http://localhost:3000')
-      console.log('\u{1F449} GET  /api/user/:id  (GET: api/user/1)')
-    } catch (err) {
-      console.error('Error starting Fastify server:', err)
-      app.log.error(err)
-      process.exit(1)
-    }
-  } catch (error) {
-    console.error('Error during bootstrap or server setup:', error)
-    process.exit(1)
-  }
-}
+      const result = await ContainerUtils.runExecute(
+        endpoint,
+        req.method,
+        req.headers,
+        { reply, req },
+        app,
+        action,
+      )
 
-runDemo()
-\`\`\`
+      return reply.send(result)
+    })
+      \`\`\`
+
+The HTTP adapter is responsible for HTTP. The application handler is responsible
+for the use case.
 
 ---
 
-## \u{1F6E0} Scaffold your project with CLI
+## CQRS & Pipelines
+
+Cross-cutting behavior can be composed around commands and queries:
+
+\`\`\`typescript
+      .addPipeline((config) => {
+        config.authorization.policies = {
+          FIND_USER_QUERY_HANDLER: {
+            roles: ['admin'],
+            permissions: ['read'],
+          },
+        }
+
+        config.commandBus.idempotency = {
+          lockTtlSeconds: 30,
+          processedTtlSeconds: 60,
+        }
+
+        config.commandBus.concurrency = {
+          delayConfig: {
+            baseDelayMs: 100,
+            maxJitterMs: 500,
+          },
+          maxRetries: 3,
+        }
 
-Xeno includes an official CLI tool, \`@xeno-js/cli\`, designed to bootstrap your
-new application in seconds. It offers an interactive setup to select exactly the
-modules you need (Database, HTTP, Auth, Logging, etc.), ensuring you start with
-a clean, pre-configured architecture tailored to your specific requirements.
+        config.queryBus.isEnabled = true
+      })
+      \`\`\`
 
-If you want to learn how to use it, see the full options available, or
-understand how the scaffolding engine works, check the
-**[CLI Documentation](https://www.xeno-js.it/cli/overview)**.
+The exact pipeline configuration depends on the integrations enabled by your
+application.
 
 ---
 
-## \u{1F91D} For Contributors
+## Infrastructure & Integrations
 
-We welcome contributions to Xeno! To maintain the highest code quality and
-stability of the core framework, **direct pushes to the \`main\` and \`develop\`
-branches are strictly prohibited.** Please follow this Git Flow to contribute:
+Xeno Core can be composed with infrastructure such as:
 
-1. **Branch off from \`develop\`**: Create a new branch for your feature or
-   bugfix.
+- **Database:** Drizzle ORM, PostgreSQL, LibSQL
+- **Cache / distributed coordination:** Redis
+- **Authentication:** Supabase integrations and custom strategies
+- **HTTP clients:** Axios
+- **Resilience:** Cockatiel
+- **Logging:** Console, Pino, Sentry, or custom loggers
+- **Validation:** Zod
 
-\`\`\`bash
-   git checkout develop
-   git pull origin develop
-   git checkout -b feat/your-awesome-feature
-\`\`\`
+These integrations are opt-in rather than mandatory parts of the application
+architecture.
+
+---
 
-2. **Make your changes**: Write your code and ensure it passes all local checks
-   (linting, types, and tests).
+## CLI
+
+Use the official CLI to scaffold a Xeno application:
 
 \`\`\`bash
-npm run check
-\`\`\`
+npm install @xeno-js / cli
+    xeno - js new my - xeno - app--core
+      \`\`\`
 
-3. **Commit your changes**: We enforce
-   [Conventional Commits](https://www.conventionalcommits.org/). Husky will
-   verify your commit message format.
+See the [CLI documentation](https://www.xeno-js.it/cli/overview).
 
-4. **Commit Format:**
+---
 
-\`\`\`bash
-feat(scope): add new feature
-fix(scope): resolve bug
-chore(scope): update dependencies
-\`\`\`
+## Documentation
 
-5. **Submit a Pull Request (PR)**: Push your branch to GitHub and open a Pull
-   Request targeting the **\`develop\`** branch.
+The documentation hub contains the architecture and integration guides:
 
-6. **Review**: The repository owner will review your code, run pipeline tests,
-   and merge it into \`develop\`.
+**[xeno-js.it](https://www.xeno-js.it/introduction)**
 
-_Note: The \`main\` branch is strictly reserved for production releases. Code
-flows from feature branches \u27A1\uFE0F \`develop\` \u27A1\uFE0F \`main\`._
+Recommended starting points:
 
-### Scripts
+- [Introduction](https://www.xeno-js.it/introduction)
+- [Fundamentals](https://www.xeno-js.it/docs/core/overview)
+- [Dependency Injection](https://www.xeno-js.it/docs/core/fundamentals/app-builder)
+- [CQRS](https://www.xeno-js.it/docs/core/fundamentals/command-query)
+- [Pipelines](https://www.xeno-js.it/docs/core/cqrs/overview)
+- [Request Lifecycle](https://www.xeno-js.it/docs/core/fundamentals/service-container)
+- [Middleware](https://www.xeno-js.it/docs/core/fundamentals/middleware)
+- [CLI](https://www.xeno-js.it/docs/cli/overview)
 
-| Command                 | Description                                    |
-| ----------------------- | ---------------------------------------------- |
-| \`npm run build\`         | Builds the TypeScript source code into \`dist/\` |
-| \`npm run typecheck\`     | Checks types without emitting files            |
-| \`npm run lint\`          | Runs ESLint                                    |
-| \`npm run format\`        | Formats code with Prettier                     |
-| \`npm run test\`          | Runs the Vitest test suite                     |
-| \`npm run test:coverage\` | Runs tests and generates a coverage report     |
+---
 
-### Code Quality (Husky & Git Hooks)
+## Ecosystem
 
-This project strictly enforces code quality rules before pushing to the
-repository:
+Xeno is designed as an ecosystem rather than a single monolithic package:
 
-- **\`pre-commit\`**: Runs \`lint-staged\` on staged files (ESLint + Prettier).
-- **\`commit-msg\`**: Checks commit messages with \`commitlint\` (we use
-  Conventional Commits).
-- **\`pre-push\`**: Runs type checking, linting, and testing before code leaves
-  your machine.
+| Package           | Role                                      |
+| ----------------- | ----------------------------------------- |
+| \`@xeno-js / core\`   | Application architecture and backend core |
+| \`@xeno-js / shared\` | Shared contracts and types                |
+| \`@xeno-js / vue\`    | Vue integration                           |
+| \`@xeno-js / cli\`    | Project scaffolding and developer tooling |
 
 ---
 
-## \u{1F331} Support & Appreciation
+## What Xeno Is Not
 
-Building, benchmarking, and maintaining a progressive, enterprise-ready
-open-source framework requires a massive amount of continuous dedication and
-architectural engineering.
+Xeno is not primarily an HTTP framework.
 
-If Xeno has brought value to your development workflows, helped decouple your
-core business logic, or simplified your system infrastructure layout, consider
-supporting its open-source lifecycle. Your backing directly accelerates our
-strategic roadmap for new out-of-the-box transport integrations (such as gRPC,
-RabbitMQ, and GraphQL) and keeps the documentation pristine.
+If you are looking for a framework centered on routing, controllers, middleware,
+and server lifecycle, there are excellent options already available in the
+Node.js ecosystem.
 
-**Want to know how you can contribute or sponsor Xeno?** We rely on the
-commitment of our community to keep the project independent and thriving.
-Whether you are an individual developer or a business using Xeno, your support
-makes a real difference.
+Xeno focuses on the layer above transport:
 
-\u{1F449}
-**[Read our support guidelines and find out how to help](https://www.xeno-js.it/support-us)**
+> **How should a TypeScript application be structured so that its business
+> logic, dependencies, and infrastructure boundaries remain explicit as the
+> application grows?**
 
-Thank you for being part of this decoupled open-source journey!
+---
 
-<amp-bounce>
-</amp-bounce>
-<a href="https://www.buymeacoffee.com/xenojs" target="_blank">
-<img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me A Coffee" height="42" style="height: 42px !important;" />
-</a>
+## Production Considerations
+
+Xeno provides architectural primitives, but application correctness still
+depends on how those primitives are composed.
+
+Before deploying an application, test the behaviors that matter to your
+workload, especially:
+
+- request and transaction isolation
+- service lifetime boundaries
+- authorization policies
+- idempotency semantics
+- concurrency behavior
+- cache consistency
+- failure and retry behavior
+- trusted proxy / client IP configuration
+- database transaction boundaries
+
+The framework is designed to make these boundaries explicit rather than hide
+them behind conventions.
 
 ---
 
-## \u{1F6E1}\uFE0F Powered by Xeno
-
-If you are using Xeno in your project, let the world know! Add this badge to
-your README:
-
-\`\`\`html
-<a
-  href="[https://github.com/xeno-js/xeno-js](https://github.com/xeno-js/xeno-js)"
-  target="_blank"
->
-  <img
-    src="[https://img.shields.io/badge/Powered%20by-Xeno-black?style=flat-square](https://img.shields.io/badge/Powered%20by-Xeno-black?style=flat-square)"
-    alt="Powered by Xeno"
-    height="20"
-  />
-</a>
-\`\`\`
+## Contributing
 
-## \u{1F4C4} License
+Contributions are welcome.
 
-Copyright (c) 2026 Xeno. Licensed under the [ISC License](LICENSE).
+Development happens from feature branches targeting \`develop\`.
 
-        `;
+\`\`\`bash
+git checkout develop
+git pull origin develop
+git checkout - b feat / your - feature
+
+npm install
+npm run check
+      \`\`\`
+
+We use Conventional Commits:
+
+\`\`\`bash
+    feat(scope): add new feature
+    fix(scope): resolve bug
+    chore(scope): update dependencies
+      \`\`\`
+
+Before opening a pull request, run:
+
+\`\`\`bash
+npm run check
+      \`\`\`
+
+| Command                 | Description              |
+| ----------------------- | ------------------------ |
+| \`npm run build\`         | Build the package        |
+| \`npm run typecheck\`     | TypeScript type checking |
+| \`npm run lint\`          | ESLint                   |
+| \`npm run format: check\`  | Prettier validation      |
+| \`npm run test\`          | Vitest test suite        |
+| \`npm run test: coverage\` | Test suite with coverage |
+
+---
+
+## Support
+
+If Xeno is useful to you, you can support the project through the community and
+sponsorship channels documented on the website:
+
+**[Support Xeno](https://www.xeno-js.it/docs/support-us)**
+
+---
+
+## License
+
+Copyright (c) 2026 Xeno.
+
+Licensed under the [MIT License](LICENSE).
+`;
         const filePath = import_node_path25.default.join(projectPath, "readme");
         await this._fileService.writeFileRecursive(filePath, content);
       }
@@ -3050,13 +3377,12 @@ var init_tsconfig_generator2 = __esm({
   "src/infrastructure/generators/core/tsconfig.generator.ts"() {
     "use strict";
     import_node_path27 = __toESM(require("path"));
-    init_shared();
     TsconfigGenerator = class {
       constructor(_fileService) {
         this._fileService = _fileService;
       }
       _fileService;
-      async generate(projectPath, options) {
+      async generate(projectPath, _options) {
         const tsconfig = {
           compilerOptions: {
             target: "ES2022",
@@ -3075,9 +3401,6 @@ var init_tsconfig_generator2 = __esm({
           },
           include: ["src/**/*.ts"]
         };
-        if (options.database === CORE_CONSTANTS.DRIZZLE || options.database === CORE_CONSTANTS.SQL_LITE) {
-          tsconfig.include.push("drizzle.config.ts");
-        }
         const filePath = import_node_path27.default.join(projectPath, "tsconfig.json");
         await this._fileService.writeFileRecursive(filePath, JSON.stringify(tsconfig, null, 2));
       }
@@ -3111,7 +3434,8 @@ var init_drizzle_generator = __esm({
         );
       }
       composeDrizzleConfig() {
-        return `import 'dotenv/config';
+        return `/// <reference types="node" />
+import 'dotenv/config';
 import { defineConfig } from 'drizzle-kit';
 
 /**
@@ -3191,7 +3515,8 @@ var init_drizzle_sql_lite_generator = __esm({
         await this._fileService.writeFileRecursive(schemaPath, schemaContent);
       }
       composeDrizzleConfig() {
-        return `import 'dotenv/config';
+        return `/// <reference types="node" />
+import 'dotenv/config';
 import { defineConfig } from 'drizzle-kit';
 
 /**
@@ -3400,7 +3725,7 @@ var CommandRunner = class {
       const child = (0, import_node_child_process.spawn)(cmd, args, {
         cwd,
         stdio: "inherit",
-        shell: false
+        shell: isWin
       });
       child.on("error", (error) => {
         reject(new Error(`Error during execution of the command ${command}: ${error.message}`));
@@ -3420,11 +3745,16 @@ init_command_constants();
 
 // src/infrastructure/file/file.service.ts
 var import_promises = require("fs/promises");
-var import_path = require("path");
 var FileUtils = class {
   async writeFileRecursive(filePath, content) {
-    const dir = (0, import_path.dirname)(filePath);
-    await (0, import_promises.mkdir)(dir, { recursive: true });
+    try {
+      await (0, import_promises.access)(filePath);
+      throw new Error(`[Xeno CLI Error]: Aborted. File already exists at path: ${filePath}`);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
     await (0, import_promises.writeFile)(filePath, content, "utf8");
   }
 };