@xeno-js/cli 0.1.0 → 0.1.2

package/dist/index.js

@@ -1,11 +1,3680 @@
 #!/usr/bin/env node
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-const picocolors_1 = __importDefault(require("picocolors"));
-const builder_1 = require("./infrastructure/builder");
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/shared/constants/command.constants.ts
+var ARGS_CONSTANTS, COMMAND_CONSTANTS, TARGET_ENV_CONSTANTS;
+var init_command_constants = __esm({
+  "src/shared/constants/command.constants.ts"() {
+    "use strict";
+    ARGS_CONSTANTS = Object.freeze({
+      HELP: "--help",
+      VUE: "--vue",
+      CORE: "--core",
+      CONSOLE: "--console"
+    });
+    COMMAND_CONSTANTS = Object.freeze({
+      HELP: "help",
+      COMMAND: "command",
+      QUERY: "query"
+    });
+    TARGET_ENV_CONSTANTS = Object.freeze({
+      CONSOLE: "console",
+      VERCEL: "vercel",
+      FASTIFY: "fastify"
+    });
+  }
+});
+
+// src/shared/constants/core.constants.ts
+var CORE_CONSTANTS;
+var init_core_constants = __esm({
+  "src/shared/constants/core.constants.ts"() {
+    "use strict";
+    CORE_CONSTANTS = Object.freeze({
+      VERCEL: "vercel",
+      FASTIFY: "fastify",
+      DRIZZLE: "drizzle",
+      SQL_LITE: "sqlLite",
+      NONE: "none"
+    });
+  }
+});
+
+// src/shared/constants/index.ts
+var init_constants = __esm({
+  "src/shared/constants/index.ts"() {
+    "use strict";
+    init_command_constants();
+    init_core_constants();
+  }
+});
+
+// src/shared/utils/guards.utils.ts
+var OBJECT_TAG, DATE_TAG, Guards;
+var init_guards_utils = __esm({
+  "src/shared/utils/guards.utils.ts"() {
+    "use strict";
+    OBJECT_TAG = "[object Object]";
+    DATE_TAG = "[object Date]";
+    Guards = Object.freeze({
+      /**
+       * @description Checks value is neither null nor undefined.
+       * @param value Candidate value.
+       * @returns True when value is defined.
+      
+       * 
+       * @author Xeno
+       * @version 1.0.0
+       * @since 2025-09-30
+       * @link https://github.com/xeno-js/xeno-js 
+       */
+      isDefined(value) {
+        return value !== null && value !== void 0 && value !== "" && !Number.isNaN(value);
+      },
+      /**
+       * @description Checks value is null, undefined, empty string, or false.
+       * @param value Candidate value.
+       * @returns True when value is null, undefined, empty string, or false.
+      
+       * 
+       * @author Xeno
+       * @version 1.0.0
+       * @since 2025-09-30
+       * @link https://github.com/xeno-js/xeno-js 
+       */
+      isNullOrEmpty(value) {
+        return !Guards.isDefined(value) || Guards.isString(value) && value.trim() === "" || Guards.isArray(value) && value.length === 0;
+      },
+      /**
+       * @description Throws an error if the value is null, undefined, empty string, or false.
+       * @param value Candidate value.
+       * @param errorMessage Error message to throw if the check fails.
+       * @throws Error with the provided message if the value is null, undefined, empty string, or false.
+      
+       * 
+       * @author Xeno
+       * @version 1.0.0
+       * @since 2025-09-30
+       * @link https://github.com/xeno-js/xeno-js 
+       */
+      throwIfNullOrEmpty(value, errorMessage) {
+        if (Guards.isNullOrEmpty(value)) {
+          throw new Error(errorMessage);
+        }
+      },
+      /**
+       * @description Throws an error if the value is not a positive integer.
+       * @param value Candidate value.
+       * @param errorMessage Error message to throw if the check fails.
+       * @throws Error with the provided message if the value is not a positive integer.
+      
+       * 
+       * @author Xeno
+       * @version 1.0.0
+       * @since 2025-09-30
+       * @link https://github.com/xeno-js/xeno-js 
+       */
+      throwIfNegative(value, errorMessage) {
+        if (Guards.isInteger(value) && value < 0) {
+          throw new Error(errorMessage);
+        }
+      },
+      /**
+       * @description Throws an error if the value is not an integer.
+       * @param value Candidate value.
+       * @param errorMessage Error message to throw if the check fails.
+       * @throws Error with the provided message if the value is not an integer.
+      
+       * 
+       * @author Xeno
+       * @version 1.0.0
+       * @since 2025-09-30
+       * @link https://github.com/xeno-js/xeno-js 
+       */
+      throwIfNotInteger(value, errorMessage) {
+        if (!Guards.isInteger(value)) {
+          throw new Error(errorMessage);
+        }
+      },
+      /**
+       * @description Checks if an object has a method with the given name.
+       * @param obj Object to check.
+       * @param methodName Name of the method to look for.
+       * @returns True when obj has a function property named methodName.
+      
+       * 
+       * @author Xeno
+       * @version 1.0.0
+       * @since 2025-09-30
+       * @link https://github.com/xeno-js/xeno-js 
+       */
+      hasMethod(obj, methodName) {
+        if (!this.isDefined(obj)) return false;
+        return Guards.isFunction(obj[methodName]);
+      },
+      /**
+       * @description Checks value is a string.
+       * @param value Candidate value.
+       * @returns True when value is string.
+      
+       * 
+       * @author Xeno
+       * @version 1.0.0
+       * @since 2025-09-30
+       * @link https://github.com/xeno-js/xeno-js 
+       */
+      isString(value) {
+        return typeof value === "string";
+      },
+      /**
+       * @description Checks value is a finite number.
+       * @param value Candidate value.
+       * @returns True when value is finite number.
+      
+       * 
+       * @author Xeno
+       * @version 1.0.0
+       * @since 2025-09-30
+       * @link https://github.com/xeno-js/xeno-js 
+       */
+      isNumber(value) {
+        return typeof value === "number" && Number.isFinite(value);
+      },
+      /**
+       * @description Checks value is an integer number.
+       * @param value Candidate value.
+       * @returns True when value is integer number.
+      
+       * 
+       * @author Xeno
+       * @version 1.0.0
+       * @since 2025-09-30
+       * @link https://github.com/xeno-js/xeno-js 
+       */
+      isInteger(value) {
+        return Guards.isNumber(value) && Number.isInteger(value);
+      },
+      /**
+       * @description Checks value is boolean.
+       * @param value Candidate value.
+       * @returns True when value is boolean.
+      
+       * 
+       * @author Xeno
+       * @version 1.0.0
+       * @since 2025-09-30
+       * @link https://github.com/xeno-js/xeno-js 
+       */
+      isBoolean(value) {
+        return typeof value === "boolean";
+      },
+      /**
+       * @description Checks value is bigint.
+       * @param value Candidate value.
+       * @returns True when value is bigint.
+      
+       * 
+       * @author Xeno
+       * @version 1.0.0
+       * @since 2025-09-30
+       * @link https://github.com/xeno-js/xeno-js 
+       */
+      isBigInt(value) {
+        return typeof value === "bigint";
+      },
+      /**
+       * @description Checks value is symbol.
+       * @param value Candidate value.
+       * @returns True when value is symbol.
+      
+       * 
+       * @author Xeno
+       * @version 1.0.0
+       * @since 2025-09-30
+       * @link https://github.com/xeno-js/xeno-js 
+       */
+      isSymbol(value) {
+        return typeof value === "symbol";
+      },
+      /**
+       * @description Checks value is a function.
+       * @param value Candidate value.
+       * @returns True when value is function.
+      
+       * 
+       * @author Xeno
+       * @version 1.0.0
+       * @since 2025-09-30
+       * @link https://github.com/xeno-js/xeno-js 
+       */
+      isFunction(value) {
+        return typeof value === "function";
+      },
+      /**
+       * @description Checks value is an array.
+       * @param value Candidate value.
+       * @returns True when value is array.
+      
+       * 
+       * @author Xeno
+       * @version 1.0.0
+       * @since 2025-09-30
+       * @link https://github.com/xeno-js/xeno-js 
+       */
+      isArray(value) {
+        return Array.isArray(value);
+      },
+      /**
+       * @description Checks value is a Date instance with valid timestamp.
+       * @param value Candidate value.
+       * @returns True when value is valid Date.
+      
+       * 
+       * @author Xeno
+       * @version 1.0.0
+       * @since 2025-09-30
+       * @link https://github.com/xeno-js/xeno-js 
+       */
+      isDate(value) {
+        if (Object.prototype.toString.call(value) !== DATE_TAG) {
+          return false;
+        }
+        return Number.isFinite(value.getTime());
+      },
+      /**
+       * @description Checks value is an Error instance.
+       * @param value Candidate value.
+       * @returns True when value is Error.
+      
+       * 
+       * @author Xeno
+       * @version 1.0.0
+       * @since 2025-09-30
+       * @link https://github.com/xeno-js/xeno-js 
+       */
+      isError(value) {
+        return value instanceof Error;
+      },
+      /**
+       * @description Checks value is a plain object record.
+       * @param value Candidate value.
+       * @returns True when value is object record.
+      
+       * 
+       * @author Xeno
+       * @version 1.0.0
+       * @since 2025-09-30
+       * @link https://github.com/xeno-js/xeno-js 
+       */
+      isObjectRecord(value) {
+        if (!Guards.isDefined(value)) {
+          return false;
+        }
+        return Object.prototype.toString.call(value) === OBJECT_TAG;
+      },
+      /**
+       * @description Checks value is an object (not null).
+       * @param value Candidate value.
+       * @returns True when value is object.
+      
+       * 
+       * @author Xeno
+       * @version 1.0.0
+       * @since 2025-09-30
+       * @link https://github.com/xeno-js/xeno-js 
+       */
+      isObject(value) {
+        return typeof value === "object" && Guards.isDefined(value);
+      },
+      /**
+       * @description Checks value is PromiseLike.
+       * @param value Candidate value.
+       * @returns True when value has then function.
+      
+       * 
+       * @author Xeno
+       * @version 1.0.0
+       * @since 2025-09-30
+       * @link https://github.com/xeno-js/xeno-js 
+       */
+      isPromiseLike(value) {
+        if (!Guards.isDefined(value)) {
+          return false;
+        }
+        if (!Guards.isObject(value) && !Guards.isFunction(value)) {
+          return false;
+        }
+        const thenMember = value["then"];
+        return Guards.isFunction(thenMember);
+      }
+    });
+  }
+});
+
+// src/shared/utils/string.utils.ts
+var StringUtils;
+var init_string_utils = __esm({
+  "src/shared/utils/string.utils.ts"() {
+    "use strict";
+    init_guards_utils();
+    StringUtils = Object.freeze({
+      /**
+       * @description Inserisce un underscore (_) tra la fine di una parola e l'inizio della successiva in formato camelCase o PascalCase.
+       * @param input Stringa in input (es. "CreateUser").
+       * @returns Stringa separata da underscore (es. "Create_User").
+       *
+       * @author Xeno
+       * @version 1.0.0
+       * @since 2026-09-18
+       * @link https://github.com/xeno-js/xeno-js
+       */
+      splitCamelCaseWithUnderscore(input) {
+        if (!Guards.isString(input) || Guards.isNullOrEmpty(input)) return input;
+        return input.replace(/([a-z])([A-Z])/g, "$1_$2");
+      },
+      /**
+       * @description Converts a string to camelCase.
+       * @param input Input string (supports snake_case, kebab-case, or space-separated).
+       * @returns camelCase string.
+      
+       * 
+       * @author Xeno
+       * @version 1.0.0
+       * @since 2025-09-30
+       * @link https://github.com/xeno-js/xeno-js 
+       */
+      camelCase(input) {
+        const segments = input.split(/[-_\s]+/);
+        const [first, ...rest] = segments;
+        const head = Guards.isDefined(first) ? first.toLowerCase() : "";
+        return head + rest.map((seg) => seg.charAt(0).toUpperCase() + seg.slice(1)).join("");
+      },
+      /**
+       * @description Converts a string to PascalCase.
+       * @param input Input string (supports snake_case, kebab-case, space-separated, or camelCase).
+       * @returns PascalCase string.
+       *
+       * @author Xeno
+       * @version 1.0.0
+       * @since 2026-09-18
+       * @link https://github.com/xeno-js/xeno-js
+       */
+      pascalCase(input) {
+        if (!Guards.isString(input) || Guards.isNullOrEmpty(input)) return "";
+        const segments = input.split(/[-_\s]+/);
+        return segments.filter((seg) => seg.length > 0).map((seg) => {
+          const normalized = seg === seg.toUpperCase() ? seg.toLowerCase() : seg;
+          return normalized.charAt(0).toUpperCase() + normalized.slice(1);
+        }).join("");
+      }
+    });
+  }
+});
+
+// src/shared/utils/index.ts
+var init_utils = __esm({
+  "src/shared/utils/index.ts"() {
+    "use strict";
+    init_guards_utils();
+    init_string_utils();
+  }
+});
+
+// src/shared/index.ts
+var init_shared = __esm({
+  "src/shared/index.ts"() {
+    "use strict";
+    init_constants();
+    init_utils();
+  }
+});
+
+// src/infrastructure/generators/core/command/generate-command.generator.ts
+var generate_command_generator_exports = {};
+__export(generate_command_generator_exports, {
+  GenerateCommandCoreGenerator: () => GenerateCommandCoreGenerator
+});
+var import_node_path, GenerateCommandCoreGenerator;
+var init_generate_command_generator = __esm({
+  "src/infrastructure/generators/core/command/generate-command.generator.ts"() {
+    "use strict";
+    import_node_path = __toESM(require("path"));
+    GenerateCommandCoreGenerator = class {
+      constructor(_fileService) {
+        this._fileService = _fileService;
+      }
+      _fileService;
+      async generate(pascalName, lowerName, tokenPrefix, componentDir, hasZod, hasDrizzle) {
+        const commandContent = `import { Command } from '@xeno-js/core';
+
+/*
+ * \u26A0\uFE0F WARNING: ACTION REQUIRED \u26A0\uFE0F
+ * Please replace <any> with your specific payload and response types.
+ */
+export class ${pascalName}Command extends Command<any> {
+    constructor(public readonly payload: any) {
+        super('${tokenPrefix}_COMMAND_HANDLER');
+    }
+}
+`;
+        await this._fileService.writeFileRecursive(
+          import_node_path.default.join(componentDir, `${lowerName}.command.ts`),
+          commandContent
+        );
+        const handlerContent = `import type { IFactory, ResultType, UserContext } from '@xeno-js/core';
+import { AppError, BaseHandler, Result } from '@xeno-js/core';
+import { ${pascalName}Command } from './${lowerName}.command';
+
+/*
+ * \u26A0\uFE0F WARNING: ACTION REQUIRED \u26A0\uFE0F
+ * Please replace <any> with your specific response type.
+ */
+export class ${pascalName}Handler extends BaseHandler<${pascalName}Command, any> {
+    constructor(
+        identityFactory: IFactory<void, UserContext>
+    ) {
+        super(identityFactory);
+    }
+
+    public async executeAsync(request: ${pascalName}Command, singal: AbortSignal): Promise<ResultType<any>> {
+        // TODO: Implement your business logic here
+
+        return Result.ok();
+    }
+}
+`;
+        await this._fileService.writeFileRecursive(
+          import_node_path.default.join(componentDir, `${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';
+
+/*
+ * \u26A0\uFE0F WARNING: ACTION REQUIRED \u26A0\uFE0F
+ * Please replace <any, any> with your specific request and response types.
+ */
+export class ${pascalName}Controller extends BaseController<any, any> {
+    constructor(
+        requestContext: IContextAccessor<RequestContext>,
+        mediator: IMediator,
+    ) {
+        super(requestContext, mediator);
+    }
+
+    public async handle(request: any): Promise<ResponseDto<any>> {
+        const cmd = new ${pascalName}Command(request);
+        const result = await this._send(cmd);
+
+        if (!result.isOk()) {
+            return this.fail(result.getErrorOrThrow(), 'Error during ${pascalName} operation');
+        }
+
+        return this.ok(result.getValueOrThrow());
+    }
+}
+`;
+        await this._fileService.writeFileRecursive(
+          import_node_path.default.join(componentDir, `${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_path.default.join(componentDir, `${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
+});
+`;
+          await this._fileService.writeFileRecursive(
+            import_node_path.default.join(componentDir, `${lowerName}.schema-zod.ts`),
+            zodContent
+          );
+        }
+        if (hasDrizzle) {
+          const dbContent = `import { pgTable, text, timestamp } from 'drizzle-orm/pg-core';
+// Note: If you are using SQLite, change the import to 'drizzle-orm/sqlite-core' and update the table definition.
+
+/*
+ * \u26A0\uFE0F WARNING: ACTION REQUIRED \u26A0\uFE0F
+ * Update the schema definition with your actual database columns.
+ */
+export const ${lowerName}s = pgTable('${lowerName}s', {
+    id: text('id').primaryKey(),
+    createdAt: timestamp('created_at').defaultNow(),
+    updatedAt: timestamp('updated_at').defaultNow().$onUpdate(() => new Date()),
+});
+
+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`),
+            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';
+
+export const ${pascalName}Module = Object.freeze({
+    register(opts: IServiceContainer<any>, _config: IConfigurationService): void {
+        opts.addTransient('${tokenPrefix}_COMMAND_CONTROLLER', (c) => new ${pascalName}Controller(c.resolve(TOKENS.REQUEST_CONTEXT), c.resolve(TOKENS.MEDIATOR)));
+        opts.addScoped('${tokenPrefix}_COMMAND_HANDLER', (c) => new ${pascalName}Handler(c.resolve(TOKENS.USER_CONTEXT_FACTORY)));
+
+        /*
+         * \u26A0\uFE0F WARNING: ACTION REQUIRED \u26A0\uFE0F
+         * Please copy and paste the following tokens to your MyRegistry interface (usually in src/registry.ts):
+         *
+         * ${tokenPrefix}_COMMAND_CONTROLLER: IController<any, any>;
+         * ${tokenPrefix}_COMMAND_HANDLER: IHandler<${pascalName}Command, any>;
+         */
+    }
+} as const);
+`;
+        await this._fileService.writeFileRecursive(
+          import_node_path.default.join(componentDir, `${lowerName}.module.ts`),
+          moduleContent
+        );
+      }
+    };
+  }
+});
+
+// src/infrastructure/generators/core/command/generate-query.generator.ts
+var generate_query_generator_exports = {};
+__export(generate_query_generator_exports, {
+  GenerateQueryCoreGenerator: () => GenerateQueryCoreGenerator
+});
+var import_node_path2, GenerateQueryCoreGenerator;
+var init_generate_query_generator = __esm({
+  "src/infrastructure/generators/core/command/generate-query.generator.ts"() {
+    "use strict";
+    import_node_path2 = __toESM(require("path"));
+    GenerateQueryCoreGenerator = class {
+      constructor(_fileService) {
+        this._fileService = _fileService;
+      }
+      _fileService;
+      async generate(pascalName, lowerName, tokenPrefix, componentDir, hasZod) {
+        const queryContent = `import { BaseQuery } from '@xeno-js/core';
+
+/*
+ * \u26A0\uFE0F WARNING: ACTION REQUIRED \u26A0\uFE0F
+ * Please replace <any> with your specific payload and response types.
+ */
+export class ${pascalName}Query extends BaseQuery<any> {
+    constructor(public readonly payload: any) {
+        super(
+            '${tokenPrefix}_QUERY_HANDLER', 
+            // Default cache options:
+            {
+                ttl: 60,
+                cacheKey: \`${lowerName}:\${JSON.stringify(payload)}\`,
+                bypassCache: false,
+                consistentRead: false
+                isUserScoped: false,
+            }
+        );
+    }
+}
+`;
+        await this._fileService.writeFileRecursive(
+          import_node_path2.default.join(componentDir, `${lowerName}.query.ts`),
+          queryContent
+        );
+        const handlerContent = `import type { IFactory, ResultType, UserContext } from '@xeno-js/core';
+import { AppError, BaseHandler, Result } from '@xeno-js/core';
+import { ${pascalName}Query } from './${lowerName}.query';
+
+/*
+ * \u26A0\uFE0F WARNING: ACTION REQUIRED \u26A0\uFE0F
+ * Please replace <any> with your specific response type.
+ */
+export class ${pascalName}Handler extends BaseHandler<${pascalName}Query, any> {
+    constructor(
+        identityFactory: IFactory<void, UserContext>
+        // TODO: Inject your ReadDao or DataSource here
+    ) {
+        super(identityFactory);
+    }
+
+    public async executeAsync(request: ${pascalName}Query, singal: AbortSignal): Promise<ResultType<any>> {
+        // TODO: Implement your query logic here
+
+        return Result.ok();
+    }
+}
+`;
+        await this._fileService.writeFileRecursive(
+          import_node_path2.default.join(componentDir, `${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';
+
+/*
+ * \u26A0\uFE0F WARNING: ACTION REQUIRED \u26A0\uFE0F
+ * Please replace <any, any> with your specific request and response types.
+ */
+export class ${pascalName}Controller extends BaseController<any, any> {
+    constructor(
+        requestContext: IContextAccessor<RequestContext>,
+        mediator: IMediator,
+    ) {
+        super(requestContext, mediator);
+    }
+
+    public async handle(request: any): Promise<ResponseDto<any>> {
+        const query = new ${pascalName}Query(request);
+        const result = await this._query(query);
+
+        if (!result.isOk()) {
+            return this.fail(result.getErrorOrThrow(), 'Error during ${pascalName} operation');
+        }
+
+        return this.ok(result.getValueOrThrow());
+    }
+}
+`;
+        await this._fileService.writeFileRecursive(
+          import_node_path2.default.join(componentDir, `${lowerName}.controller.ts`),
+          controllerContent
+        );
+        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.
+ */
+export const ${pascalName}Schema = ZodUtils.createQuerySchema({
+    payload: z.any() // TODO: Update with strict validation
+});
+`;
+          await this._fileService.writeFileRecursive(
+            import_node_path2.default.join(componentDir, `${lowerName}.schema-zod.ts`),
+            zodContent
+          );
+        }
+        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';
+
+export const ${pascalName}Module = Object.freeze({
+    register(opts: IServiceContainer<any>, _config: IConfigurationService): void {
+        opts.addTransient('${tokenPrefix}_QUERY_CONTROLLER', (c) => new ${pascalName}Controller(c.resolve(TOKENS.REQUEST_CONTEXT), c.resolve(TOKENS.MEDIATOR)));
+        opts.addScoped('${tokenPrefix}_QUERY_HANDLER', (c) => new ${pascalName}Handler(c.resolve(TOKENS.USER_CONTEXT_FACTORY)));
+
+        /*
+         * \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>;
+         */
+    }
+} as const);
+`;
+        await this._fileService.writeFileRecursive(
+          import_node_path2.default.join(componentDir, `${lowerName}.module.ts`),
+          moduleContent
+        );
+      }
+    };
+  }
+});
+
+// src/infrastructure/generators/core/command/cqrs.generator.ts
+var cqrs_generator_exports = {};
+__export(cqrs_generator_exports, {
+  CqrsGenerator: () => CqrsGenerator
+});
+var import_promises2, import_node_path3, CqrsGenerator;
+var init_cqrs_generator = __esm({
+  "src/infrastructure/generators/core/command/cqrs.generator.ts"() {
+    "use strict";
+    import_promises2 = __toESM(require("fs/promises"));
+    import_node_path3 = __toESM(require("path"));
+    init_shared();
+    CqrsGenerator = class {
+      constructor(_fileService) {
+        this._fileService = _fileService;
+      }
+      _fileService;
+      async generate(targetDir, name, type, outputPath) {
+        const pascalName = StringUtils.pascalCase(name);
+        const tokenPrefix = StringUtils.splitCamelCaseWithUnderscore(pascalName).toUpperCase();
+        const lowerName = name.toLowerCase();
+        const destinationFolder = outputPath ?? lowerName;
+        const componentDir = import_node_path3.default.join(targetDir, "src", destinationFolder);
+        let hasZod = false;
+        let hasDrizzle = false;
+        try {
+          const pkgJsonStr = await import_promises2.default.readFile(import_node_path3.default.join(targetDir, "package.json"), "utf8");
+          const pkgJson = JSON.parse(pkgJsonStr);
+          const deps = { ...pkgJson.dependencies ?? {}, ...pkgJson.devDependencies ?? {} };
+          hasZod = !!Guards.isDefined(deps["zod"]);
+          hasDrizzle = !!Guards.isDefined(deps["drizzle-orm"]);
+        } catch (error) {
+          console.warn(
+            "  Warning: Could not read package.json. Assuming Zod and Drizzle are not installed.",
+            error
+          );
+        }
+        switch (type) {
+          case COMMAND_CONSTANTS.COMMAND: {
+            const { GenerateCommandCoreGenerator: GenerateCommandCoreGenerator2 } = await Promise.resolve().then(() => (init_generate_command_generator(), generate_command_generator_exports));
+            const generator = new GenerateCommandCoreGenerator2(this._fileService);
+            return generator.generate(
+              pascalName,
+              lowerName,
+              tokenPrefix,
+              componentDir,
+              hasZod,
+              hasDrizzle
+            );
+          }
+          case COMMAND_CONSTANTS.QUERY: {
+            const { GenerateQueryCoreGenerator: GenerateQueryCoreGenerator2 } = await Promise.resolve().then(() => (init_generate_query_generator(), generate_query_generator_exports));
+            const generatorQuery = new GenerateQueryCoreGenerator2(this._fileService);
+            return generatorQuery.generate(pascalName, lowerName, tokenPrefix, componentDir, hasZod);
+          }
+          default:
+            throw new Error(`Unsupported generator type: '${String(type)}'. Use 'command' or 'query'.`);
+        }
+      }
+    };
+  }
+});
+
+// src/infrastructure/generators/vue/command_query/generate-command-vue.generator.ts
+var generate_command_vue_generator_exports = {};
+__export(generate_command_vue_generator_exports, {
+  GenerateCommandVueGenerator: () => GenerateCommandVueGenerator
+});
+var import_node_path4, GenerateCommandVueGenerator;
+var init_generate_command_vue_generator = __esm({
+  "src/infrastructure/generators/vue/command_query/generate-command-vue.generator.ts"() {
+    "use strict";
+    import_node_path4 = __toESM(require("path"));
+    GenerateCommandVueGenerator = class {
+      constructor(_fileService) {
+        this._fileService = _fileService;
+      }
+      _fileService;
+      async generate(pascalName, lowerName, tokenPrefix, componentDir) {
+        const commandContent = `import { Command } from '@xeno-js/vue';
+
+export class ${pascalName}Command extends Command {
+    constructor() {
+        super('${tokenPrefix}_COMMAND');
+    }
+}
+`;
+        await this._fileService.writeFileRecursive(
+          import_node_path4.default.join(componentDir, `${lowerName}.command.ts`),
+          commandContent
+        );
+        const handlerContent = `import type { IHandler, ResultType } from '@xeno-js/vue';
+import { AppError, Result } from '@xeno-js/vue';
+import type { ${pascalName}Command } from './${lowerName}.command';
+import type { ${pascalName}Response } from './${lowerName}.model';
+
+/*
+ * \u26A0\uFE0F WARNING: ACTION REQUIRED \u26A0\uFE0F
+ * 
+ * Please register your handler in the IoC container (e.g. src/bootstrap.ts) and add its token to MyRegistry.
+ *
+ * 1. In src/registry.ts:
+ * ${tokenPrefix}_HANDLER: IHandler<${pascalName}Command, ${pascalName}Response>;
+ * 
+ * 2. In src/bootstrap.ts:
+ * .addServices((config, register) => {
+ *     register('${tokenPrefix}_HANDLER', new ${pascalName}Handler());
+ * });
+ */
+export class ${pascalName}Handler implements IHandler<${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);
+
+        // 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`),
+          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';
+
+/*
+ * \u26A0\uFE0F WARNING: ACTION REQUIRED \u26A0\uFE0F
+ *
+ * Please register your handler in the IoC container (e.g. src/bootstrap.ts) and add its token to MyRegistry.
+ *
+ * 1. In src/registry.ts:
+ * ${tokenPrefix}_HANDLER: IHandler<${pascalName}Command, ${pascalName}Response>;
+ * 
+ * 2. In src/bootstrap.ts:
+ * .addServices((config, register) => {
+ *     register('${tokenPrefix}_HANDLER', new ${pascalName}Handler());
+ * });
+ */
+export function use${pascalName}() {
+    const loading = ref(false);
+    const error = ref<string | null>(null);
+    let abortController: AbortController | null = null;
+
+    const execute = async (payload: ${pascalName}Request): Promise<ResultType<${pascalName}Response>> => {
+        abortController = new AbortController();
+        
+        if (loading.value) return Result.fail(AppError.create({
+            name: '${pascalName}Command',
+            message: '${pascalName}Command is already in progress',
+            code: '${tokenPrefix}_COMMAND_ALREADY_IN_PROGRESS',
+            status: 500,
+            cause: new Error('${tokenPrefix}_COMMAND_ALREADY_IN_PROGRESS'),
+        }));
+        loading.value = true;
+        error.value = null;
+
+        try {
+            // Resolve mediator and handler from the container
+            const { mediator, ${tokenPrefix}_HANDLER: handler } = ServicesUtils.useApp();
+            const command = new ${pascalName}Command();
+
+            const result = await mediator.send(command, async () => {
+                return await handler.handle(command, abortController?.signal);
+            });
+
+            if (!result.isOk()) {
+                error.value = result.getErrorOrThrow().message;
+            }
+
+            return result;
+        } finally {
+            loading.value = false;
+        }
+    };
+
+    const abort = () => {
+        if (abortController) {
+            abortController.abort();
+        }
+    };
+
+    // Automatically cancel pending operations when the component unmounts
+    onUnmounted(() => {
+        abort();
+    });
+
+    return { loading, error, execute };
+}
+`;
+        await this._fileService.writeFileRecursive(
+          import_node_path4.default.join(componentDir, `use-${lowerName}.composable.ts`),
+          composableContent
+        );
+        const modelContent = `export interface ${pascalName}Request {
+    // TODO: Define your request payload properties here
+}
+
+export interface ${pascalName}Response {
+    // TODO: Define your response properties here
+}
+`;
+        await this._fileService.writeFileRecursive(
+          import_node_path4.default.join(componentDir, `${lowerName}.model.ts`),
+          modelContent
+        );
+      }
+    };
+  }
+});
+
+// src/infrastructure/generators/vue/command_query/generate-query-vue.generator.ts
+var generate_query_vue_generator_exports = {};
+__export(generate_query_vue_generator_exports, {
+  GenerateQueryVueGenerator: () => GenerateQueryVueGenerator
+});
+var import_node_path5, GenerateQueryVueGenerator;
+var init_generate_query_vue_generator = __esm({
+  "src/infrastructure/generators/vue/command_query/generate-query-vue.generator.ts"() {
+    "use strict";
+    import_node_path5 = __toESM(require("path"));
+    GenerateQueryVueGenerator = class {
+      constructor(_fileService) {
+        this._fileService = _fileService;
+      }
+      _fileService;
+      async generate(pascalName, lowerName, tokenPrefix, componentDir) {
+        const queryContent = `import { Query } from '@xeno-js/vue';
+import type { ${pascalName}Response } from './${lowerName}.model';
+
+export class ${pascalName}Query extends Query<${pascalName}Response> {
+    constructor() {
+        super('${tokenPrefix}_QUERY', {
+            ttl: 60,
+            cacheKey: \`${lowerName}.query\`,
+            bypassCache: false,
+            consistentRead: false,
+            isUserScoped: true
+        });
+    }
+}
+`;
+        await this._fileService.writeFileRecursive(
+          import_node_path5.default.join(componentDir, `${lowerName}.query.ts`),
+          queryContent
+        );
+        const handlerContent = `import type { IHandler, ResultType } from '@xeno-js/vue';
+import { AppError, Result } from '@xeno-js/vue';
+import type { ${pascalName}Query } from './${lowerName}.query';
+import type { ${pascalName}Response } from './${lowerName}.model';
+
+    /*
+ * \u26A0\uFE0F WARNING: ACTION REQUIRED \u26A0\uFE0F
+ *
+ * Please register your handler in the IoC container (e.g. src/bootstrap.ts) and add its token to MyRegistry.
+ *
+ * 1. In src/registry.ts:
+ * ${tokenPrefix}_HANDLER: IHandler<${pascalName}Query, ${pascalName}Response>;
+ * 
+ * 2. In src/bootstrap.ts:
+ * .addServices((config, register) => {
+ *     register('${tokenPrefix}_HANDLER', new ${pascalName}Handler());
+ * });
+ */
+export class ${pascalName}Handler implements IHandler<${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);
+
+        // 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`),
+          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';
+
+export function use${pascalName}() {
+    const loading = ref(false);
+    const error = ref<string | null>(null);
+    const data = ref<${pascalName}Response | null>(null);
+    let abortController: AbortController | null = null;
+
+    /*
+ * \u26A0\uFE0F WARNING: ACTION REQUIRED \u26A0\uFE0F
+ *
+ * Please register your handler in the IoC container (e.g. src/bootstrap.ts) and add its token to MyRegistry.
+ *
+ * 1. In src/registry.ts:
+ * ${tokenPrefix}_HANDLER: IHandler<${pascalName}Query, ${pascalName}Response>;
+ * 
+ * 2. In src/bootstrap.ts:
+ * .addServices((config, register) => {
+ *     register('${tokenPrefix}_HANDLER', new ${pascalName}Handler());
+ * });
+ */
+const fetch = async (): Promise<ResultType<${pascalName}Response>> => {
+        abortController = new AbortController();
+
+        if (loading.value) return Result.fail(AppError.create({
+            name: '${pascalName}Query',
+            message: '${pascalName}Query is already in progress',
+            code: '${tokenPrefix}_QUERY_ALREADY_IN_PROGRESS',
+            status: 500,
+            cause: new Error('${tokenPrefix}_QUERY_ALREADY_IN_PROGRESS'),
+        }));
+        loading.value = true;
+        error.value = null;
+
+        try {
+            try {
+            // Resolve mediator and handler from the container
+            const { mediator, ${tokenPrefix}_HANDLER: handler } = ServicesUtils.useApp();
+            const query = new ${pascalName}Query();
+
+            const result = await mediator.query(query, async () => {
+                return await handler.handle(query, abortController?.signal);
+            });
+
+            if (result.isOk()) {
+                data.value = result.getValueOrThrow();
+            } else {
+                error.value = result.getErrorOrThrow().message;
+            }
+
+            return result;
+        } finally {
+            loading.value = false;
+        }
+    };
+
+    const abort = () => {
+        if (abortController) {
+            abortController.abort();
+        }
+    };
+
+    // Automatically cancel pending operations when the component unmounts
+    onUnmounted(() => {
+        abort();
+    });
+
+    return { loading, error, data, fetch };
+}
+`;
+        await this._fileService.writeFileRecursive(
+          import_node_path5.default.join(componentDir, `use-${lowerName}.composable.ts`),
+          composableContent
+        );
+        const modelContent = `export interface ${pascalName}Response {
+    // TODO: Define your response properties here
+}
+`;
+        await this._fileService.writeFileRecursive(
+          import_node_path5.default.join(componentDir, `${lowerName}.model.ts`),
+          modelContent
+        );
+      }
+    };
+  }
+});
+
+// src/infrastructure/generators/vue/command_query/cqrs.generator.ts
+var cqrs_generator_exports2 = {};
+__export(cqrs_generator_exports2, {
+  CqrsVueGenerator: () => CqrsVueGenerator
+});
+var import_node_path6, CqrsVueGenerator;
+var init_cqrs_generator2 = __esm({
+  "src/infrastructure/generators/vue/command_query/cqrs.generator.ts"() {
+    "use strict";
+    import_node_path6 = __toESM(require("path"));
+    init_shared();
+    CqrsVueGenerator = class {
+      constructor(_fileService) {
+        this._fileService = _fileService;
+      }
+      _fileService;
+      async generate(targetDir, name, type, outputPath) {
+        const pascalName = StringUtils.pascalCase(name);
+        const tokenPrefix = StringUtils.splitCamelCaseWithUnderscore(pascalName).toUpperCase();
+        const lowerName = name.toLowerCase();
+        const destinationFolder = outputPath ?? lowerName;
+        const componentDir = import_node_path6.default.join(targetDir, "src", destinationFolder);
+        switch (type) {
+          case COMMAND_CONSTANTS.COMMAND: {
+            const { GenerateCommandVueGenerator: GenerateCommandVueGenerator2 } = await Promise.resolve().then(() => (init_generate_command_vue_generator(), generate_command_vue_generator_exports));
+            const generator = new GenerateCommandVueGenerator2(this._fileService);
+            return generator.generate(pascalName, lowerName, tokenPrefix, componentDir);
+          }
+          case COMMAND_CONSTANTS.QUERY: {
+            const { GenerateQueryVueGenerator: GenerateQueryVueGenerator2 } = await Promise.resolve().then(() => (init_generate_query_vue_generator(), generate_query_vue_generator_exports));
+            const generatorQuery = new GenerateQueryVueGenerator2(this._fileService);
+            return generatorQuery.generate(pascalName, lowerName, tokenPrefix, componentDir);
+          }
+          default:
+            throw new Error(`Unsupported generator type: '${String(type)}'. Use 'command' or 'query'.`);
+        }
+      }
+    };
+  }
+});
+
+// src/infrastructure/generators/vue/packagejson.generator.ts
+var packagejson_generator_exports = {};
+__export(packagejson_generator_exports, {
+  PackageJsonVueGenerator: () => PackageJsonVueGenerator
+});
+var import_node_path8, PackageJsonVueGenerator;
+var init_packagejson_generator = __esm({
+  "src/infrastructure/generators/vue/packagejson.generator.ts"() {
+    "use strict";
+    import_node_path8 = __toESM(require("path"));
+    PackageJsonVueGenerator = class {
+      constructor(_fileService) {
+        this._fileService = _fileService;
+      }
+      _fileService;
+      async generate(projectPath, options) {
+        const packageJson = {
+          name: options.targetDir,
+          version: "1.0.0",
+          private: true,
+          type: "module",
+          scripts: {
+            dev: "vite",
+            build: "vue-tsc -b && vite build",
+            preview: "vite preview",
+            g: "xeno-js generate"
+          },
+          dependencies: {
+            "@xeno-js/vue": "latest",
+            "vue": "^3.5.0"
+          },
+          devDependencies: {
+            "@types/node": "^20.0.0",
+            "@vitejs/plugin-vue": "^5.1.0",
+            "typescript": "^5.5.0",
+            "vite": "^5.4.0",
+            "vue-tsc": "^2.1.0"
+          }
+        };
+        if (options.axios) packageJson.dependencies["axios"] = "^1.7.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.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.tailwind) {
+          packageJson.devDependencies["tailwindcss"] = "^4.0.0";
+          packageJson.devDependencies["@tailwindcss/vite"] = "^4.0.0";
+        }
+        const filePath = import_node_path8.default.join(projectPath, "package.json");
+        await this._fileService.writeFileRecursive(filePath, JSON.stringify(packageJson, null, 2));
+      }
+    };
+  }
+});
+
+// src/infrastructure/generators/vue/vite-config.generator.ts
+var vite_config_generator_exports = {};
+__export(vite_config_generator_exports, {
+  ViteconfigGenerator: () => ViteconfigGenerator
+});
+var import_node_path9, ViteconfigGenerator;
+var init_vite_config_generator = __esm({
+  "src/infrastructure/generators/vue/vite-config.generator.ts"() {
+    "use strict";
+    import_node_path9 = __toESM(require("path"));
+    ViteconfigGenerator = class {
+      constructor(_fileService) {
+        this._fileService = _fileService;
+      }
+      _fileService;
+      async generate(projectPath, options) {
+        const tailwindImport = options.tailwind ? `
+import tailwindcss from '@tailwindcss/vite';` : "";
+        const tailwindPlugin = options.tailwind ? `
+    tailwindcss(),` : "";
+        const content = `import { defineConfig } from 'vite';
+import vue from '@vitejs/plugin-vue';${tailwindImport}
+import path from 'node:path';
+
+export default defineConfig({
+  plugins: [
+    vue(),${tailwindPlugin}
+  ],
+  resolve: {
+    alias: {
+      '@': path.resolve(__dirname, './src'),
+    },
+  },
+  server: {
+    port: 5173,
+  }
+});
+`;
+        const filePath = import_node_path9.default.join(projectPath, "vite.config.ts");
+        await this._fileService.writeFileRecursive(filePath, content);
+      }
+    };
+  }
+});
+
+// src/infrastructure/generators/vue/env.generator.ts
+var env_generator_exports = {};
+__export(env_generator_exports, {
+  EnvVueGenerator: () => EnvVueGenerator
+});
+var import_node_path10, EnvVueGenerator;
+var init_env_generator = __esm({
+  "src/infrastructure/generators/vue/env.generator.ts"() {
+    "use strict";
+    import_node_path10 = __toESM(require("path"));
+    EnvVueGenerator = class {
+      constructor(_fileService) {
+        this._fileService = _fileService;
+      }
+      _fileService;
+      async generate(projectPath, options) {
+        let content = `# \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\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
+# Xeno VUE APPLICATION ENVIRONMENT VARIABLES
+# \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\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
+VITE_APP_ENV=development
+`;
+        if (options.axios) {
+          content += `
+# --- Axios ---
+VITE_API_BASE_URL=http://localhost:3000
+`;
+        }
+        if (options.supabase) {
+          content += `
+# --- Authentication (Supabase) ---
+VITE_SUPABASE_URL=https://your-project.supabase.co
+VITE_SUPABASE_KEY=your-anon-key
+`;
+        }
+        if (options.sentry) {
+          content += `
+# --- Error Tracking (Sentry) ---
+VITE_SENTRY_DSN=https://your-sentry-dsn@o0.ingest.sentry.io/0
+`;
+        }
+        await this._fileService.writeFileRecursive(import_node_path10.default.join(projectPath, ".env"), content);
+        await this._fileService.writeFileRecursive(import_node_path10.default.join(projectPath, ".env.example"), content);
+      }
+    };
+  }
+});
+
+// src/infrastructure/generators/vue/tsconfig.generator.ts
+var tsconfig_generator_exports = {};
+__export(tsconfig_generator_exports, {
+  TsconfigVueGenerator: () => TsconfigVueGenerator
+});
+var import_node_path11, TsconfigVueGenerator;
+var init_tsconfig_generator = __esm({
+  "src/infrastructure/generators/vue/tsconfig.generator.ts"() {
+    "use strict";
+    import_node_path11 = __toESM(require("path"));
+    TsconfigVueGenerator = class {
+      constructor(_fileService) {
+        this._fileService = _fileService;
+      }
+      _fileService;
+      async generate(projectPath, _options) {
+        const tsconfig = {
+          compilerOptions: {
+            target: "ES2022",
+            useDefineForClassFields: true,
+            module: "ESNext",
+            moduleResolution: "bundler",
+            strict: true,
+            jsx: "preserve",
+            resolveJsonModule: true,
+            isolatedModules: true,
+            esModuleInterop: true,
+            lib: ["ES2022", "DOM", "DOM.Iterable"],
+            skipLibCheck: true,
+            noEmit: true,
+            types: ["vite/client"],
+            paths: {
+              "@/*": ["./src/*"]
+            }
+          },
+          include: ["src/**/*.ts", "src/**/*.d.ts", "src/**/*.tsx", "src/**/*.vue"]
+        };
+        await this._fileService.writeFileRecursive(
+          import_node_path11.default.join(projectPath, "tsconfig.json"),
+          JSON.stringify(tsconfig, null, 2)
+        );
+      }
+    };
+  }
+});
+
+// src/infrastructure/generators/vue/readme.generator.ts
+var readme_generator_exports = {};
+__export(readme_generator_exports, {
+  ReadmeVueGenerator: () => ReadmeVueGenerator
+});
+var import_node_path12, ReadmeVueGenerator;
+var init_readme_generator = __esm({
+  "src/infrastructure/generators/vue/readme.generator.ts"() {
+    "use strict";
+    import_node_path12 = __toESM(require("path"));
+    ReadmeVueGenerator = class {
+      constructor(_fileService) {
+        this._fileService = _fileService;
+      }
+      _fileService;
+      async generate(projectPath, options) {
+        const content = `# ${options.targetDir}
+
+<div align="center">
+  <img src="logo/logo.png" alt="Xeno Logo" width="140" />
+
+  <h1>Xeno Vue</h1>
+
+  <p><em>Enterprise-grade DDD & CQRS framework for Vue.js</em></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" />
+    </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>
+  </p>
+</div>
+
+---
+
+## 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.
+
+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.
+
+---
+
+## \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.
+
+---
+
+## \u{1F4D6} Documentation & Getting Started
+
+To explore the architecture, programmatic configurations, and extension
+workflows of Xeno Vue, read the full technical manuals located inside the main
+documentation hub:
+
+- **[Framework Documentation Repository](https://www.xeno-js.it/vue/overview)**
+
+Inside, you will find exhaustive, step-by-step assembly guides covering frontend
+IoC building (\`XenoAppBuilder\`), Vue \`Provide/Inject\` boundaries, and CQRS
+composables.
+
+---
+
+## \u{1F680} Live Executable Demos
+
+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.
+
+- **[Xeno Vue Demo Architecture](https://www.xeno-js.it/demo)**
+
+---
+
+## \u{1F4E6} Installation
+
+Install the Vue package:
+
+\`\`\`bash
+npm install @xeno-js/vue
+
+\`\`\`
+
+Xeno uses **Optional Peer Dependencies**. You only install the external
+libraries you actually need.
+
+\`\`\`bash
+# Example: Install tools only if you enable them in the builder
+npm install axios cockatiel zod @supabase/supabase-js @sentry/vue
+
+\`\`\`
+
+---
+
+## \u26A1 Bootstrapping & Component Example
+
+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.
+
+### 1. Initialize the Container (\`src/bootstrap.ts\`)
+
+\`\`\`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,
+    }
+    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()
+}
+\`\`\`
+
+### 2. Inject into Vue (\`src/main.ts\`)
+
+\`\`\`typescript
+import { createApp } from 'vue'
+import App from './App.vue'
+import { bootstrap } from './bootstrap'
+import { XENO_SERVICES_KEY, ServicesUtils } from '@xeno-js/vue'
+
+async function mountApp() {
+  try {
+    const app = createApp(App)
+    const container = await bootstrap()
+
+    // Provide the Xeno IoC container globally to all components
+    app.provide(XENO_SERVICES_KEY, container)
+
+    // Register global services utility for composables
+    ServicesUtils.setGlobalServices(container)
+
+    app.mount('#app')
+  } catch (error) {
+    console.error('Critical error during frontend bootstrap:', error)
+  }
+}
+
+mountApp()
+\`\`\`
+
+### 3. CQRS Composable Usage (\`src/features/users/use-create-user.ts\`)
+
+\`\`\`typescript
+import { ref } from 'vue'
+import { Result } from '@xeno-js/shared'
+import { ServicesUtils } from '@/use-app'
+import { CreateUserCommand } from './create-user.command'
+
+export function useCreateUser() {
+  const loading = ref(false)
+  const error = ref<string | null>(null)
+
+  const execute = async (payload: { email: string; name: string }) => {
+    if (loading.value) return Result.fail(new Error('Already executing'))
+    loading.value = true
+    error.value = null
+
+    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)
+
+        if (!apiResult.isOk()) return Result.fail(apiResult.getErrorOrThrow())
+        return Result.ok(apiResult.getValueOrThrow())
+      })
+
+      if (!result.isOk()) {
+        error.value = result.getErrorOrThrow().message
+      }
+
+      return result
+    } finally {
+      loading.value = false
+    }
+  }
+
+  return { loading, error, execute }
+}
+\`\`\`
+
+---
+
+## \u{1F6E0} Scaffold your project with CLI
+
+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.
+
+\`\`\`bash
+# Generate a new Vue project
+npx @xeno-js/cli new my-frontend-app --vue
+
+# Generate a Vue Command with its Composable
+npx @xeno-js/cli g command CreateUser --vue
+
+\`\`\`
+
+Check the
+**[CLI Documentation](https://www.google.com/search?q=https://www.xeno-js.it/cli/overview&utm_source=gemini)**
+for full options.
+
+---
+
+## \u{1F91D} For Contributors
+
+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:
+
+1. **Branch off from \`develop**\`: Create a new branch for your feature or
+   bugfix.
+
+\`\`\`bash
+git checkout develop
+git pull origin develop
+git checkout -b feat/your-awesome-feature
+
+\`\`\`
+
+2. **Make your changes**: Write your code and ensure it passes all local checks
+   (linting, types, and tests).
+
+\`\`\`bash
+npm run check
+
+\`\`\`
+
+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:**
+
+\`\`\`bash
+feat(scope): add new feature
+fix(scope): resolve bug
+chore(scope): update dependencies
+
+\`\`\`
+
+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\`.
+
+_Note: The \`main\` branch is strictly reserved for production releases. Code
+flows from feature branches \u27A1\uFE0F \`develop\` \u27A1\uFE0F \`main\`._
+
+### Scripts
+
+| 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)
+
+This project strictly enforces code quality rules before pushing to the
+repository:
+
+- **\`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.
+
+---
+
+## \u{1F331} Support & Appreciation
+
+Building, benchmarking, and maintaining a progressive, enterprise-ready
+open-source framework requires a massive amount of continuous dedication and
+architectural engineering.
+
+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.
+
+**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.
+
+\u{1F449}
+**[Read our support guidelines and find out how to help](https://www.xeno-js.it/support-us)**
+
+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>
+
+---
+
+## \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>
+\`\`\`
+
+## \u{1F4C4} License
+
+Copyright (c) 2026 Xeno. Licensed under the
+[ISC License](https://www.google.com/search?q=LICENSE&utm_source=gemini).
+`;
+        await this._fileService.writeFileRecursive(import_node_path12.default.join(projectPath, "README.md"), content);
+      }
+    };
+  }
+});
+
+// src/infrastructure/generators/gitignore.generator.ts
+var gitignore_generator_exports = {};
+__export(gitignore_generator_exports, {
+  GitIgnoreGenerator: () => GitIgnoreGenerator
+});
+var import_node_path13, GitIgnoreGenerator;
+var init_gitignore_generator = __esm({
+  "src/infrastructure/generators/gitignore.generator.ts"() {
+    "use strict";
+    import_node_path13 = __toESM(require("path"));
+    init_shared();
+    GitIgnoreGenerator = class {
+      constructor(_fileService) {
+        this._fileService = _fileService;
+      }
+      _fileService;
+      async generate(projectPath, options) {
+        let content = `# Dependencies
+node_modules/
+
+# Build artifacts
+dist/
+out/
+build/
+
+# Environment variables
+# We ignore actual .env files for security, but keep .env.example for documentation
+.env
+.env.local
+.env.*
+!.env.example
+
+# Logs
+*.log
+logs/
+npm-debug.log*
+
+# Test coverage
+coverage/
+.nyc_output/
+
+# OS and IDE
+.DS_Store
+Thumbs.db
+.vscode/
+.idea/
+`;
+        if (options.database === CORE_CONSTANTS.SQL_LITE) {
+          content += `
+# SQLite Database
+*.sqlite
+*.sqlite3
+*.sqlite-journal
+`;
+        }
+        if (options.targetEnv === CORE_CONSTANTS.VERCEL) {
+          content += `
+# Vercel
+.vercel/
+`;
+        }
+        const filePath = import_node_path13.default.join(projectPath, ".gitignore");
+        await this._fileService.writeFileRecursive(filePath, content);
+      }
+    };
+  }
+});
+
+// src/infrastructure/generators/vue/app-vue.generator.ts
+var app_vue_generator_exports = {};
+__export(app_vue_generator_exports, {
+  AppVueGenerator: () => AppVueGenerator
+});
+var import_node_path14, AppVueGenerator;
+var init_app_vue_generator = __esm({
+  "src/infrastructure/generators/vue/app-vue.generator.ts"() {
+    "use strict";
+    import_node_path14 = __toESM(require("path"));
+    AppVueGenerator = class {
+      constructor(_fileService) {
+        this._fileService = _fileService;
+      }
+      _fileService;
+      async generate(projectPath, options) {
+        const appVue = `<script setup lang="ts">
+</script>
+
+<template>
+  <div id="xeno-app">
+    ${options.router ? "<router-view />" : "<h1>Welcome to Xeno Vue App</h1>"}
+  </div>
+</template>`;
+        await this._fileService.writeFileRecursive(import_node_path14.default.join(projectPath, "src", "App.vue"), appVue);
+      }
+    };
+  }
+});
+
+// src/infrastructure/generators/vue/bootstrap-ts.generator.ts
+var bootstrap_ts_generator_exports = {};
+__export(bootstrap_ts_generator_exports, {
+  BootstrapGenerator: () => BootstrapGenerator
+});
+var import_node_path15, BootstrapGenerator;
+var init_bootstrap_ts_generator = __esm({
+  "src/infrastructure/generators/vue/bootstrap-ts.generator.ts"() {
+    "use strict";
+    import_node_path15 = __toESM(require("path"));
+    BootstrapGenerator = class {
+      constructor(_fileService) {
+        this._fileService = _fileService;
+      }
+      _fileService;
+      async generate(projectPath, options) {
+        let builderNodes = `  const builder = XenoAppBuilder.create<MyRegistry>()
+    .addContext(() => {})`;
+        if (options.supabase) {
+          builderNodes += `
+    .addAuth((opts, config) => {
+      opts.url = config.getOrThrow('VITE_SUPABASE_URL');
+      opts.key = config.getOrThrow('VITE_SUPABASE_KEY');
+    })`;
+        }
+        if (options.sentry) {
+          builderNodes += `
+    .addLogger((opts, config) => {
+      const env = config.get(COMMON_CONSTANTS.ENV) ?? 'development'
+      const isDev = env.toLowerCase() === 'development'
+      opts.console = isDev
+      if (!isDev) {
+        opts.sentry = {
+            dsn: config.getOrThrow('VITE_SENTRY_DSN'),
+            env,
+            app,
+            router,
+            tracesSampleRate: 0.2,
+            level: LOG_LEVEL.WARN,
+        };
+      }
+    })`;
+        } else {
+          builderNodes += `
+    .addLogger((opts, config) => {
+      opts.console = config.get('VITE_APP_ENV') === 'development';
+    })`;
+        }
+        builderNodes += `
+    .addServices((config, register) => {
+      // Register custom stores, API clients, and CQRS services here
+    })`;
+        const bootstrapTs = `import { XenoAppBuilder, LOG_LEVEL } from '@xeno-js/vue';
+import type { MyRegistry } from './registry';
+
+export async function bootstrap(app: any, router: any) {
+${builderNodes}
+
+  return await builder.build();
+}
+`;
+        await this._fileService.writeFileRecursive(
+          import_node_path15.default.join(projectPath, "src", "bootstrap.ts"),
+          bootstrapTs
+        );
+      }
+    };
+  }
+});
+
+// src/infrastructure/generators/vue/index-html.generator.ts
+var index_html_generator_exports = {};
+__export(index_html_generator_exports, {
+  IndexVueGenerator: () => IndexVueGenerator
+});
+var import_node_path16, IndexVueGenerator;
+var init_index_html_generator = __esm({
+  "src/infrastructure/generators/vue/index-html.generator.ts"() {
+    "use strict";
+    import_node_path16 = __toESM(require("path"));
+    IndexVueGenerator = class {
+      constructor(_fileService) {
+        this._fileService = _fileService;
+      }
+      _fileService;
+      async generate(projectPath, options) {
+        const indexHtml = `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>${options.targetDir}</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>`;
+        await this._fileService.writeFileRecursive(import_node_path16.default.join(projectPath, "index.html"), indexHtml);
+      }
+    };
+  }
+});
+
+// src/infrastructure/generators/vue/main.generator.ts
+var main_generator_exports = {};
+__export(main_generator_exports, {
+  MainGenerator: () => MainGenerator
+});
+var import_node_path17, MainGenerator;
+var init_main_generator = __esm({
+  "src/infrastructure/generators/vue/main.generator.ts"() {
+    "use strict";
+    import_node_path17 = __toESM(require("path"));
+    MainGenerator = class {
+      constructor(_fileService) {
+        this._fileService = _fileService;
+      }
+      _fileService;
+      async generate(projectPath, options) {
+        const routerImport = options.router ? `
+import router from './router';` : "";
+        const piniaImport = options.pinia ? `
+import { createPinia } from 'pinia';` : "";
+        const tailwindImport = options.tailwind ? `
+import './assets/style.css';` : "";
+        const mainTs = `import { createApp } from 'vue';
+import App from './App.vue';
+import { bootstrap } from './bootstrap';
+import { XENO_SERVICES_KEY } from '@xeno-js/vue';${routerImport}${piniaImport}${tailwindImport}
+
+async function mountApp() {
+  try {
+    const app = createApp(App);
+    ${options.pinia ? "\n    app.use(createPinia());" : ""}
+    const container = await bootstrap(app, router);
+    ${options.router ? "\n    app.use(router);" : ""}
+    
+
+    // Provide the Xeno IoC container globally to all components
+    app.provide(XENO_SERVICES_KEY, container);
+
+    app.mount('#app');
+  } catch (error) {
+    console.error('Critical error during frontend bootstrap:', error);
+  }
+}
+
+mountApp();
+`;
+        await this._fileService.writeFileRecursive(import_node_path17.default.join(projectPath, "src", "main.ts"), mainTs);
+      }
+    };
+  }
+});
+
+// src/infrastructure/generators/vue/registry-ts.generator.ts
+var registry_ts_generator_exports = {};
+__export(registry_ts_generator_exports, {
+  RegistryGenerator: () => RegistryGenerator
+});
+var import_node_path18, RegistryGenerator;
+var init_registry_ts_generator = __esm({
+  "src/infrastructure/generators/vue/registry-ts.generator.ts"() {
+    "use strict";
+    import_node_path18 = __toESM(require("path"));
+    RegistryGenerator = class {
+      constructor(_fileService) {
+        this._fileService = _fileService;
+      }
+      _fileService;
+      async generate(projectPath, _options) {
+        const registryTs = `import type { XenoVueRegistry } from '@xeno-js/vue';
+
+/**
+ * @file registry.ts
+ * @description Centralized Type Contract for Dependency Injection in Vue.
+ */
+export interface MyRegistry extends XenoVueRegistry {
+  // Add your frontend injection tokens here
+  // e.g., USER_DATA_SOURCE: IUserDataSource;
+}
+`;
+        await this._fileService.writeFileRecursive(
+          import_node_path18.default.join(projectPath, "src", "registry.ts"),
+          registryTs
+        );
+      }
+    };
+  }
+});
+
+// src/infrastructure/generators/vue/router.generator.ts
+var router_generator_exports = {};
+__export(router_generator_exports, {
+  RouterGenerator: () => RouterGenerator
+});
+var import_node_path19, RouterGenerator;
+var init_router_generator = __esm({
+  "src/infrastructure/generators/vue/router.generator.ts"() {
+    "use strict";
+    import_node_path19 = __toESM(require("path"));
+    RouterGenerator = class {
+      constructor(_fileService) {
+        this._fileService = _fileService;
+      }
+      _fileService;
+      async generate(projectPath, options) {
+        if (options.router) {
+          const routerTs = `import { createRouter, createWebHistory } from 'vue-router';
+
+export default createRouter({
+  history: createWebHistory(),
+  routes: [
+    {
+      path: '/',
+      name: 'Home',
+      component: () => import('../views/HomeView.vue')
+    }
+  ]
+});`;
+          await this._fileService.writeFileRecursive(
+            import_node_path19.default.join(projectPath, "src", "router", "index.ts"),
+            routerTs
+          );
+          await this._fileService.writeFileRecursive(
+            import_node_path19.default.join(projectPath, "src", "views", "HomeView.vue"),
+            `<template>
+  <h1>Home View</h1>
+</template>`
+          );
+        }
+      }
+    };
+  }
+});
+
+// src/infrastructure/generators/vue/tailwind.generator.ts
+var tailwind_generator_exports = {};
+__export(tailwind_generator_exports, {
+  TailwindGenerator: () => TailwindGenerator
+});
+var import_node_path20, TailwindGenerator;
+var init_tailwind_generator = __esm({
+  "src/infrastructure/generators/vue/tailwind.generator.ts"() {
+    "use strict";
+    import_node_path20 = __toESM(require("path"));
+    TailwindGenerator = class {
+      constructor(_fileService) {
+        this._fileService = _fileService;
+      }
+      _fileService;
+      async generate(projectPath, options) {
+        if (options.tailwind) {
+          await this._fileService.writeFileRecursive(
+            import_node_path20.default.join(projectPath, "src", "assets", "style.css"),
+            `@import "tailwindcss";
+`
+          );
+        }
+      }
+    };
+  }
+});
+
+// src/infrastructure/generators/vue/use-app.generator.ts
+var use_app_generator_exports = {};
+__export(use_app_generator_exports, {
+  UseAppVueGenerator: () => UseAppVueGenerator
+});
+var import_node_path21, UseAppVueGenerator;
+var init_use_app_generator = __esm({
+  "src/infrastructure/generators/vue/use-app.generator.ts"() {
+    "use strict";
+    import_node_path21 = __toESM(require("path"));
+    UseAppVueGenerator = class {
+      constructor(_fileService) {
+        this._fileService = _fileService;
+      }
+      _fileService;
+      async generate(projectPath, _options) {
+        const content = `import type { Nullable } from "@xeno-js/vue";
+import { Guards, XENO_SERVICES_KEY } from "@xeno-js/vue";
+import { inject } from "vue";
+import type { MyRegistry } from "./registry";
+
+let globalServices: Nullable<MyRegistry> = null;
+
+export const ServicesUtils = Object.freeze({
+    // Metodo per registrare i servizi al bootstrap
+    setGlobalServices(services: MyRegistry) {
+        globalServices = services;
+    },
+    useApp(): MyRegistry {
+        if (Guards.isDefined(globalServices))
+            return globalServices;
+
+        const services = inject<MyRegistry>(XENO_SERVICES_KEY);
+        if (!services)
+            throw new Error(
+                '[Xeno Error]: XenoServices not found. Did you provide them using app.provide(XENO_SERVICES_KEY, services)?',
+            );
+
+        return services;
+    }
+} as const);
+`;
+        await this._fileService.writeFileRecursive(import_node_path21.default.join(projectPath, "src", "use-app.ts"), content);
+      }
+    };
+  }
+});
+
+// src/infrastructure/strategies/vue-scaffold.strategy.ts
+var vue_scaffold_strategy_exports = {};
+__export(vue_scaffold_strategy_exports, {
+  VueScaffoldStrategy: () => VueScaffoldStrategy
+});
+var import_prompts, VueScaffoldStrategy;
+var init_vue_scaffold_strategy = __esm({
+  "src/infrastructure/strategies/vue-scaffold.strategy.ts"() {
+    "use strict";
+    import_prompts = __toESM(require("prompts"));
+    VueScaffoldStrategy = class {
+      constructor(_fileService) {
+        this._fileService = _fileService;
+      }
+      _fileService;
+      async promptOptions(targetDir) {
+        const response = await (0, import_prompts.default)([
+          { type: "confirm", name: "axios", message: "Install Axios?", initial: true },
+          {
+            type: "confirm",
+            name: "cockatiel",
+            message: "Install Cockatiel (Resilience)?",
+            initial: true
+          },
+          { type: "confirm", name: "supabase", message: "Install Supabase Auth?", initial: true },
+          { type: "confirm", name: "sentry", message: "Install Sentry Logger?", initial: true },
+          {
+            type: "confirm",
+            name: "pinia",
+            message: "Install Pinia (State Management)?",
+            initial: true
+          },
+          { type: "confirm", name: "router", message: "Install vue-router?", initial: true },
+          { type: "confirm", name: "tailwind", message: "Install Tailwind CSS?", initial: true },
+          { type: "confirm", name: "zod", message: "Install Zod Validator?", initial: true },
+          {
+            type: "confirm",
+            name: "gitInit",
+            message: "Initialize a new Git repository?",
+            initial: true
+          }
+        ]);
+        return {
+          targetDir,
+          projectType: "vue",
+          ...response
+        };
+      }
+      async getGenerators(_options) {
+        const generators = [];
+        const { PackageJsonVueGenerator: PackageJsonVueGenerator2 } = await Promise.resolve().then(() => (init_packagejson_generator(), packagejson_generator_exports));
+        const { ViteconfigGenerator: ViteconfigGenerator2 } = await Promise.resolve().then(() => (init_vite_config_generator(), vite_config_generator_exports));
+        const { EnvVueGenerator: EnvVueGenerator2 } = await Promise.resolve().then(() => (init_env_generator(), env_generator_exports));
+        const { TsconfigVueGenerator: TsconfigVueGenerator2 } = await Promise.resolve().then(() => (init_tsconfig_generator(), tsconfig_generator_exports));
+        const { ReadmeVueGenerator: ReadmeVueGenerator2 } = await Promise.resolve().then(() => (init_readme_generator(), readme_generator_exports));
+        const { GitIgnoreGenerator: GitIgnoreGenerator2 } = await Promise.resolve().then(() => (init_gitignore_generator(), gitignore_generator_exports));
+        const { AppVueGenerator: AppVueGenerator2 } = await Promise.resolve().then(() => (init_app_vue_generator(), app_vue_generator_exports));
+        const { BootstrapGenerator: BootstrapGenerator3 } = await Promise.resolve().then(() => (init_bootstrap_ts_generator(), bootstrap_ts_generator_exports));
+        const { IndexVueGenerator: IndexVueGenerator2 } = await Promise.resolve().then(() => (init_index_html_generator(), index_html_generator_exports));
+        const { MainGenerator: MainGenerator3 } = await Promise.resolve().then(() => (init_main_generator(), main_generator_exports));
+        const { RegistryGenerator: RegistryGenerator3 } = await Promise.resolve().then(() => (init_registry_ts_generator(), registry_ts_generator_exports));
+        const { RouterGenerator: RouterGenerator2 } = await Promise.resolve().then(() => (init_router_generator(), router_generator_exports));
+        const { TailwindGenerator: TailwindGenerator2 } = await Promise.resolve().then(() => (init_tailwind_generator(), tailwind_generator_exports));
+        const { UseAppVueGenerator: UseAppVueGenerator2 } = await Promise.resolve().then(() => (init_use_app_generator(), use_app_generator_exports));
+        generators.push(new PackageJsonVueGenerator2(this._fileService));
+        generators.push(new ViteconfigGenerator2(this._fileService));
+        generators.push(new EnvVueGenerator2(this._fileService));
+        generators.push(new TsconfigVueGenerator2(this._fileService));
+        generators.push(new AppVueGenerator2(this._fileService));
+        generators.push(new BootstrapGenerator3(this._fileService));
+        generators.push(new IndexVueGenerator2(this._fileService));
+        generators.push(new MainGenerator3(this._fileService));
+        generators.push(new RegistryGenerator3(this._fileService));
+        generators.push(new RouterGenerator2(this._fileService));
+        generators.push(new TailwindGenerator2(this._fileService));
+        generators.push(new ReadmeVueGenerator2(this._fileService));
+        generators.push(new GitIgnoreGenerator2(this._fileService));
+        generators.push(new UseAppVueGenerator2(this._fileService));
+        return generators;
+      }
+    };
+  }
+});
+
+// src/infrastructure/generators/core/packagejson.generator.ts
+var packagejson_generator_exports2 = {};
+__export(packagejson_generator_exports2, {
+  PackageJsonCoreGenerator: () => PackageJsonCoreGenerator
+});
+var import_node_path22, PackageJsonCoreGenerator;
+var init_packagejson_generator2 = __esm({
+  "src/infrastructure/generators/core/packagejson.generator.ts"() {
+    "use strict";
+    import_node_path22 = __toESM(require("path"));
+    init_shared();
+    PackageJsonCoreGenerator = class {
+      constructor(_fileService) {
+        this._fileService = _fileService;
+      }
+      _fileService;
+      async generate(projectPath, options) {
+        const packageJson = {
+          name: options.targetDir,
+          version: "1.0.0",
+          private: true,
+          main: "./dist/index.js",
+          module: "./dist/index.js",
+          types: "./dist/index.d.ts",
+          scripts: {
+            start: "tsx src/main.ts",
+            build: "tsc --project tsconfig.json",
+            g: "xeno-js generate"
+          },
+          dependencies: {
+            "@xeno-js/core": "latest",
+            "dotenv": "^16.4.5"
+          },
+          devDependencies: {
+            "@types/node": "^20.0.0",
+            "tsx": "^4.7.0",
+            "typescript": "^5.4.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.scripts["db:generate"] = "drizzle-kit generate";
+          packageJson.scripts["db:push"] = "drizzle-kit push";
+        }
+        if (options.axios) packageJson.dependencies["axios"] = "^1.16.1";
+        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";
+        const filePath = import_node_path22.default.join(projectPath, "package.json");
+        await this._fileService.writeFileRecursive(filePath, JSON.stringify(packageJson, null, 2));
+      }
+    };
+  }
+});
+
+// src/infrastructure/generators/core/bootstrap.generator.ts
+var bootstrap_generator_exports = {};
+__export(bootstrap_generator_exports, {
+  BootstrapGenerator: () => BootstrapGenerator2
+});
+var import_node_path23, BootstrapGenerator2;
+var init_bootstrap_generator = __esm({
+  "src/infrastructure/generators/core/bootstrap.generator.ts"() {
+    "use strict";
+    import_node_path23 = __toESM(require("path"));
+    init_shared();
+    BootstrapGenerator2 = class {
+      constructor(_fileService) {
+        this._fileService = _fileService;
+      }
+      _fileService;
+      async generate(projectPath, options) {
+        let builderNodes = `
+  const builder = new AppBuilder<MyRegistry>()
+    .addContext()
+    .addMiddlewares((opts) => {
+      // Add your options here
+    })
+    .addPipeline((opts) => {
+      // Add your options here
+    })`;
+        if (options.database !== CORE_CONSTANTS.NONE) {
+          if (options.database === CORE_CONSTANTS.DRIZZLE) {
+            builderNodes += `
+        .addDb((opts, config) => {
+          opts.enableSqlLite = false
+          opts.connectionString = config.getOrThrow('DATABASE_URL');
+        })`;
+          } else if (options.database === CORE_CONSTANTS.SQL_LITE) {
+            builderNodes += `
+        .addDb((opts, config) => {
+          opts.enableSqlLite = true;
+          opts.connectionString = config.getOrThrow('SQLITE_DATABASE_URL');
+        })`;
+          }
+        }
+        if (options.redis) {
+          builderNodes += `
+    .addCache((opts, config) => {
+      const isDev = config.get('NODE_ENV') === 'development';
+      opts.inMemory = isDev;
+      opts.redis = !isDev ? {
+        host: config.getOrThrow('REDIS_HOST'),
+        port: config.getNumber('REDIS_PORT') ?? 6379,
+        username: config.get('REDIS_USERNAME') ?? '',
+        password: config.get('REDIS_PASSWORD') ?? '',
+        tls: config.getBoolean('REDIS_TLS') ?? false,
+        maxRetriesPerRequest: 3
+      } : undefined
+    })`;
+        } else {
+          builderNodes += `
+    .addCache((opts) => {
+      opts.inMemory = true;
+    })`;
+        }
+        if (options.supabase) {
+          builderNodes += `
+    .addAuth((opts, config) => {
+      opts.url = config.getOrThrow('SUPABASE_URL');
+      opts.key = config.getOrThrow('SUPABASE_KEY');
+    })`;
+        }
+        if (options.pino || options.sentry) {
+          const pinoConfig = options.pino ? `opts.pino.config = !isDev ? { env: config.getOrThrow('NODE_ENV'), destination: 'stdout', prettyPrint: false } : undefined;` : "";
+          const sentryConfig = options.sentry ? `opts.sentry.config = !isDev ? { dsn: config.getOrThrow('SENTRY_DSN'), environment: config.getOrThrow('NODE_ENV') } : undefined;` : "";
+          builderNodes += `
+    .addLogger((opts, config) => {
+      const isDev = config.get('NODE_ENV') === 'development';
+      opts.level = LOG_LEVEL.INFO;
+      opts.console = isDev;
+      ${pinoConfig}
+      ${sentryConfig}
+    })`;
+        }
+        builderNodes += `
+    .addServices((opts, config) => {
+      // Register custom repositories and handlers here
+    });`;
+        const content = `import type { IServiceContainer } from '@xeno-js/core';
+import { AppBuilder, LOG_LEVEL, Nullable, TOKENS } from '@xeno-js/core';
+import type { MyRegistry } from './registry';
+
+let containerPromise: Nullable<Promise<IServiceContainer<MyRegistry>>> = null;
+
+export async function bootstrap() {
+  if (!containerPromise) {
+    containerPromise = (async () => {
+      const builder = getContainer();
+      return await builder.build();
+    })().catch((err) => {
+      containerPromise = null;
+      throw err;
+    });
+  }
+  return containerPromise;
+}
+
+function getContainer() {
+${builderNodes}
+  return builder;
+}
+`;
+        const filePath = import_node_path23.default.join(projectPath, "src", "bootstrap.ts");
+        await this._fileService.writeFileRecursive(filePath, content);
+      }
+    };
+  }
+});
+
+// src/infrastructure/generators/core/env.generator.ts
+var env_generator_exports2 = {};
+__export(env_generator_exports2, {
+  EnvGenerator: () => EnvGenerator
+});
+var import_node_path24, EnvGenerator;
+var init_env_generator2 = __esm({
+  "src/infrastructure/generators/core/env.generator.ts"() {
+    "use strict";
+    import_node_path24 = __toESM(require("path"));
+    init_shared();
+    EnvGenerator = class {
+      constructor(_fileService) {
+        this._fileService = _fileService;
+      }
+      _fileService;
+      async generate(projectPath, options) {
+        let content = `# \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\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
+# Xeno APPLICATION ENVIRONMENT VARIABLES
+# \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\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
+NODE_ENV=development
+`;
+        if (options.database !== CORE_CONSTANTS.NONE) {
+          if (options.database === CORE_CONSTANTS.DRIZZLE) {
+            content += `
+# --- Database (PostgreSQL) ---
+    DATABASE_URL=postgres://postgres:password@localhost:5432/xeno_db
+    `;
+          } else if (options.database === CORE_CONSTANTS.SQL_LITE) {
+            content += `
+# --- Database (SQLite) ---
+    SQLITE_DATABASE_URL=file:./dev.sqlite
+    `;
+          }
+        }
+        if (options.axios) {
+          content += `
+# --- Axios ---
+BASE_URL=
+`;
+        }
+        if (options.redis) {
+          content += `
+# --- Cache (Redis) ---
+REDIS_HOST=localhost
+REDIS_PORT=6379
+REDIS_PASSWORD=
+REDIS_USERNAME=
+REDIS_TLS=false
+`;
+        }
+        if (options.supabase) {
+          content += `
+# --- Authentication (Supabase) ---
+SUPABASE_URL=https://your-project.supabase.co
+SUPABASE_KEY=your-anon-key
+`;
+        }
+        if (options.sentry) {
+          content += `
+# --- Error Tracking (Sentry) ---
+SENTRY_DSN=https://your-sentry-dsn@o0.ingest.sentry.io/0
+SENTRY_ENVIRONMENT=development
+`;
+        }
+        const envPath = import_node_path24.default.join(projectPath, ".env");
+        const envExamplePath = import_node_path24.default.join(projectPath, ".env.example");
+        await this._fileService.writeFileRecursive(envPath, content);
+        await this._fileService.writeFileRecursive(envExamplePath, content);
+      }
+    };
+  }
+});
+
+// src/infrastructure/generators/core/readme.generator.ts
+var readme_generator_exports2 = {};
+__export(readme_generator_exports2, {
+  ReadmeGenerator: () => ReadmeGenerator
+});
+var import_node_path25, ReadmeGenerator;
+var init_readme_generator2 = __esm({
+  "src/infrastructure/generators/core/readme.generator.ts"() {
+    "use strict";
+    import_node_path25 = __toESM(require("path"));
+    ReadmeGenerator = class {
+      constructor(_fileService) {
+        this._fileService = _fileService;
+      }
+      _fileService;
+      async generate(projectPath, _options) {
+        const content = `
+        <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>
+
+  <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://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>
+  </p>
+</div>
+
+---
+
+## 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.
+
+---
+
+## \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.
+
+---
+
+## \u{1F4D6} Documentation & Getting Started
+
+To explore the architecture, programmatic configurations, and extension
+workflows of Xeno, read the full technical manuals located inside the main
+documentation hub:
+
+- **[Framework Documentation Repository](https://www.xeno-js.it/introduction)**
+
+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.
+
+---
+
+## \u{1F680} Live Executable Demos
+
+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.
+
+You can dive straight into the explicit source code modules of specialized
+sandbox environments:
+
+- **[\`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.
+
+---
+
+## \u{1F4E6} Installation
+
+Install the core package:
+
+\`\`\`bash
+npm install @xeno-js/core
+
+\`\`\`
+
+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.
+
+\`\`\`bash
+# Example: Install tools only if you enable them in the builder
+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.
+
+### 1. Initialize the Container and Configure Modules
+
+\`\`\`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')
+        })
+        // Configure your logger (e.g. Console, Sentry, Pino or custom logger)
+        .addLogger((config) => {
+            config.level = LOG_LEVEL.INFO
+            config.console = true
+        })
+        // 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'))
+            })
+        })
+
+\`\`\`
+
+### 2. Wrap and Run within Server Middleware (e.g., Fastify / Hono)
+
+\`\`\`typescript
+import 'dotenv/config'
+import { ContainerUtils } from '@xeno-js/core'
+import fastify from 'fastify'
+import { bootstrap } 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' });
+            }
+        );
+
+      return reply
+        .status(responseDto.status)
+        .type('application/json')
+        .send(responseDto.data)
+    })
+
+    console.log('\u2705 Routes set up. Ready to accept requests.')
+
+    // \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)
+  }
+}
+
+runDemo()
+\`\`\`
+
+---
+
+## \u{1F6E0} Scaffold your project with CLI
+
+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.
+
+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)**.
+
+---
+
+## \u{1F91D} For Contributors
+
+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:
+
+1. **Branch off from \`develop\`**: Create a new branch for your feature or
+   bugfix.
+
+\`\`\`bash
+   git checkout develop
+   git pull origin develop
+   git checkout -b feat/your-awesome-feature
+\`\`\`
+
+2. **Make your changes**: Write your code and ensure it passes all local checks
+   (linting, types, and tests).
+
+\`\`\`bash
+npm run check
+\`\`\`
+
+3. **Commit your changes**: We enforce
+   [Conventional Commits](https://www.conventionalcommits.org/). Husky will
+   verify your commit message format.
+
+4. **Commit Format:**
+
+\`\`\`bash
+feat(scope): add new feature
+fix(scope): resolve bug
+chore(scope): update dependencies
+\`\`\`
+
+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\`.
+
+_Note: The \`main\` branch is strictly reserved for production releases. Code
+flows from feature branches \u27A1\uFE0F \`develop\` \u27A1\uFE0F \`main\`._
+
+### Scripts
+
+| 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)
+
+This project strictly enforces code quality rules before pushing to the
+repository:
+
+- **\`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.
+
+---
+
+## \u{1F331} Support & Appreciation
+
+Building, benchmarking, and maintaining a progressive, enterprise-ready
+open-source framework requires a massive amount of continuous dedication and
+architectural engineering.
+
+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.
+
+**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.
+
+\u{1F449}
+**[Read our support guidelines and find out how to help](https://www.xeno-js.it/support-us)**
+
+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>
+
+---
+
+## \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>
+\`\`\`
+
+## \u{1F4C4} License
+
+Copyright (c) 2026 Xeno. Licensed under the [ISC License](LICENSE).
+
+        `;
+        const filePath = import_node_path25.default.join(projectPath, "readme");
+        await this._fileService.writeFileRecursive(filePath, content);
+      }
+    };
+  }
+});
+
+// src/infrastructure/generators/core/registry.generator.ts
+var registry_generator_exports = {};
+__export(registry_generator_exports, {
+  RegistryGenerator: () => RegistryGenerator2
+});
+var import_node_path26, RegistryGenerator2;
+var init_registry_generator = __esm({
+  "src/infrastructure/generators/core/registry.generator.ts"() {
+    "use strict";
+    import_node_path26 = __toESM(require("path"));
+    init_shared();
+    RegistryGenerator2 = class {
+      constructor(_fileService) {
+        this._fileService = _fileService;
+      }
+      _fileService;
+      async generate(projectPath, options) {
+        let dbImport = "";
+        let registryType = "";
+        if (options.database !== CORE_CONSTANTS.NONE) {
+          if (options.database === CORE_CONSTANTS.DRIZZLE) {
+            dbImport = `import type { DbSchema } from './schema';`;
+            registryType = `XenoRegistry<DbSchema>`;
+          } else if (options.database === CORE_CONSTANTS.SQL_LITE) {
+            dbImport = `import type { SqliteSchema } from './schema';`;
+            registryType = `XenoRegistry<SqliteSchema>`;
+          }
+        } else {
+          registryType = `XenoRegistry`;
+        }
+        const content = `import type { XenoRegistry } from '@xeno-js/core';
+${dbImport}
+
+/**
+ * @file registry.ts
+ * @description Centralized Type Contract for Dependency Injection.
+ */
+export interface MyRegistry extends ${registryType} {
+    // Add your application injection tokens here
+    // e.g., USER_REPOSITORY: IUserRepository;
+}
+`;
+        const filePath = import_node_path26.default.join(projectPath, "src", "registry.ts");
+        await this._fileService.writeFileRecursive(filePath, content);
+      }
+    };
+  }
+});
+
+// src/infrastructure/generators/core/tsconfig.generator.ts
+var tsconfig_generator_exports2 = {};
+__export(tsconfig_generator_exports2, {
+  TsconfigGenerator: () => TsconfigGenerator
+});
+var import_node_path27, TsconfigGenerator;
+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) {
+        const tsconfig = {
+          compilerOptions: {
+            target: "ES2022",
+            module: "ESNext",
+            moduleResolution: "bundler",
+            strict: true,
+            esModuleInterop: true,
+            skipLibCheck: true,
+            forceConsistentCasingInFileNames: true,
+            outDir: "./dist",
+            rootDir: "./src",
+            types: ["node"],
+            paths: {
+              "@/*": ["./src/*"]
+            }
+          },
+          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));
+      }
+    };
+  }
+});
+
+// src/infrastructure/generators/core/drizzle.generator.ts
+var drizzle_generator_exports = {};
+__export(drizzle_generator_exports, {
+  DrizzleGenerator: () => DrizzleGenerator
+});
+var import_node_path28, DrizzleGenerator;
+var init_drizzle_generator = __esm({
+  "src/infrastructure/generators/core/drizzle.generator.ts"() {
+    "use strict";
+    import_node_path28 = __toESM(require("path"));
+    DrizzleGenerator = class {
+      constructor(_fileService) {
+        this._fileService = _fileService;
+      }
+      _fileService;
+      async generate(projectPath, _options) {
+        const configContent = this.composeDrizzleConfig();
+        const filePath = import_node_path28.default.join(projectPath, "drizzle.config.ts");
+        await this._fileService.writeFileRecursive(filePath, configContent);
+        const schemaContent = this.composeSchema();
+        await this._fileService.writeFileRecursive(
+          import_node_path28.default.join(projectPath, "src", "schema.ts"),
+          schemaContent
+        );
+      }
+      composeDrizzleConfig() {
+        return `import 'dotenv/config';
+import { defineConfig } from 'drizzle-kit';
+
+/**
+ * Drizzle Kit configuration file.
+ * Defines the schema location, migration output directory, and database connection.
+ */
+export default defineConfig({
+  schema: './src/schema.ts',
+  out: './drizzle',
+  dialect: 'postgresql',
+  dbCredentials: {
+    url: process.env.DATABASE_URL!,
+  },
+  verbose: true,
+  strict: true,
+});
+`;
+      }
+      composeSchema() {
+        return `import { boolean, pgTable, serial, text, timestamp } from 'drizzle-orm/pg-core';
+
+/**
+ * @description Define your database tables here.
+ * The 'usersTable' serves as a baseline example. 
+ * You can add more tables, relations, and indexes according to your domain requirements.
+ */
+export const usersTable = pgTable('users', {
+  id: serial('id').primaryKey(),
+  name: text('name').notNull(),
+  email: text('email').notNull().unique(),
+  isDeleted: boolean('is_deleted').notNull().default(false),
+  deletedAt: timestamp('deleted_at'),
+  createdAt: timestamp('created_at').defaultNow(),
+});
+
+/**
+ * Types inferred from the schema.
+ * - UserDto: Represents the shape of the data retrieved from the database ($inferSelect).
+ * - NewUserDto: Represents the shape of the data required to insert a new record ($inferInsert).
+ */
+export type UserDto = typeof usersTable.$inferSelect;
+export type NewUserDto = typeof usersTable.$inferInsert;
+
+/**
+ * Centralized Database Schema dictionary.
+ */
+export type DbSchema = {
+  users: typeof usersTable;
+};
+`;
+      }
+    };
+  }
+});
+
+// src/infrastructure/generators/core/drizzle-sql-lite.generator.ts
+var drizzle_sql_lite_generator_exports = {};
+__export(drizzle_sql_lite_generator_exports, {
+  DrizzleSqlLiteGenerator: () => DrizzleSqlLiteGenerator
+});
+var import_node_path29, DrizzleSqlLiteGenerator;
+var init_drizzle_sql_lite_generator = __esm({
+  "src/infrastructure/generators/core/drizzle-sql-lite.generator.ts"() {
+    "use strict";
+    import_node_path29 = __toESM(require("path"));
+    DrizzleSqlLiteGenerator = class {
+      constructor(_fileService) {
+        this._fileService = _fileService;
+      }
+      _fileService;
+      async generate(projectPath, _options) {
+        const configContent = this.composeDrizzleConfig();
+        const filePath = import_node_path29.default.join(projectPath, "drizzle.config.ts");
+        await this._fileService.writeFileRecursive(filePath, configContent);
+        const schemaPath = import_node_path29.default.join(projectPath, "src", "schema.ts");
+        const schemaContent = this.composeSchema();
+        await this._fileService.writeFileRecursive(schemaPath, schemaContent);
+      }
+      composeDrizzleConfig() {
+        return `import 'dotenv/config';
+import { defineConfig } from 'drizzle-kit';
+
+/**
+ * Drizzle Kit configuration for SQLite / libSQL.
+ * Uses environment variable SQLITE_DATABASE_URL to locate the database.
+ */
+export default defineConfig({
+  schema: './src/schema.ts',
+  out: './drizzle',
+  dialect: 'sqlite',
+  dbCredentials: {
+    url: process.env.SQLITE_DATABASE_URL!,
+  },
+  verbose: true,
+  strict: true,
+});
+`;
+      }
+      composeSchema() {
+        return `import { sqliteTable, integer, text } from 'drizzle-orm/sqlite-core';
+
+ /**
+  * Example SQLite schema using Drizzle's libsql primitives.
+  * Place your application tables here (this file is scaffolded by the CLI when
+  * the user opts into SQLite support).
+  */
+ export const usersTable = sqliteTable('users', {
+   id: integer('id').primaryKey().notNull(),
+   name: text('name').notNull(),
+   description: text('description'),
+ });
+
+/**
+ * Types inferred from the schema.
+ * - UserDto: Represents the shape of the data retrieved from the database ($inferSelect).
+ * - NewUserDto: Represents the shape of the data required to insert a new record ($inferInsert).
+ */
+export type UserDto = typeof usersTable.$inferSelect;
+export type NewUserDto = typeof usersTable.$inferInsert;
+
+/**
+ * Centralized Database Schema dictionary.
+ */
+export type SqliteSchema = {
+  users: typeof usersTable;
+};
+`;
+      }
+    };
+  }
+});
+
+// src/infrastructure/generators/core/main.generator.ts
+var main_generator_exports2 = {};
+__export(main_generator_exports2, {
+  MainGenerator: () => MainGenerator2
+});
+var import_node_path30, MainGenerator2;
+var init_main_generator2 = __esm({
+  "src/infrastructure/generators/core/main.generator.ts"() {
+    "use strict";
+    import_node_path30 = __toESM(require("path"));
+    MainGenerator2 = class {
+      constructor(_fileService) {
+        this._fileService = _fileService;
+      }
+      _fileService;
+      async generate(projectPath, options) {
+        const content = `import 'dotenv/config';
+import { bootstrap } from './bootstrap';
+import { TOKENS } from '@xeno-js/core';
+
+/**
+ * Main Application Entry Point
+ */
+async function main() {
+  try {
+    console.info('\u23F3 Bootstrapping ${options.targetDir} application...');
+    
+    // Initialize the dependency injection container and infrastructure modules
+    const container = await bootstrap();
+    
+    const logger = container.resolve(TOKENS.LOGGER)
+    logger.info('\u2705 Application started successfully!');
+
+    // TODO: Implement your logic here
+    
+  } catch (error) {
+    console.error('\u274C Critical error during startup:', error);
+    process.exit(1);
+  }
+}
+
+main();
+`;
+        const filePath = import_node_path30.default.join(projectPath, "src", "main.ts");
+        await this._fileService.writeFileRecursive(filePath, content);
+      }
+    };
+  }
+});
+
+// src/infrastructure/strategies/core-scaffold.strategy.ts
+var core_scaffold_strategy_exports = {};
+__export(core_scaffold_strategy_exports, {
+  CoreScaffoldStrategy: () => CoreScaffoldStrategy
+});
+var import_prompts2, CoreScaffoldStrategy;
+var init_core_scaffold_strategy = __esm({
+  "src/infrastructure/strategies/core-scaffold.strategy.ts"() {
+    "use strict";
+    import_prompts2 = __toESM(require("prompts"));
+    init_shared();
+    CoreScaffoldStrategy = class {
+      constructor(_fileService) {
+        this._fileService = _fileService;
+      }
+      _fileService;
+      async promptOptions(targetDir) {
+        const response = await (0, import_prompts2.default)([
+          { type: "confirm", name: "axios", message: "Install Axios?", initial: true },
+          { type: "confirm", name: "cockatiel", message: "Install Cockatiel?", initial: true },
+          { type: "confirm", name: "supabase", message: "Install Supabase Auth?", initial: true },
+          {
+            type: "select",
+            name: "database",
+            message: "Select database type",
+            choices: [
+              { title: "Drizzle PostgreSQL", value: "drizzle" },
+              { title: "SQL Lite", value: "sqlLite" },
+              { title: "None", value: "none" }
+            ]
+          },
+          { type: "confirm", name: "pino", message: "Install Pino Logger?", initial: true },
+          { type: "confirm", name: "sentry", message: "Install Sentry Logger?", initial: true },
+          { type: "confirm", name: "redis", message: "Install Redis?", initial: true },
+          { type: "confirm", name: "zod", message: "Install Zod?", initial: true },
+          // {
+          //   type: 'select',
+          //   name: 'targetEnv',
+          //   message: 'Select target environment',
+          //   choices: [
+          //     { title: 'Console', value: 'console' },
+          //     { title: 'Vercel (Serverless)', value: 'vercel' },
+          //     { title: 'Fastify (Standalone)', value: 'fastify' },
+          //   ],
+          // },
+          {
+            type: "confirm",
+            name: "gitInit",
+            message: "Initialize a new Git repository?",
+            initial: true
+          }
+        ]);
+        return {
+          targetDir,
+          projectType: "core",
+          targetEnv: "console",
+          ...response
+        };
+      }
+      async getGenerators(options) {
+        const generators = [];
+        const { PackageJsonCoreGenerator: PackageJsonCoreGenerator2 } = await Promise.resolve().then(() => (init_packagejson_generator2(), packagejson_generator_exports2));
+        const { BootstrapGenerator: BootstrapGenerator3 } = await Promise.resolve().then(() => (init_bootstrap_generator(), bootstrap_generator_exports));
+        const { EnvGenerator: EnvGenerator2 } = await Promise.resolve().then(() => (init_env_generator2(), env_generator_exports2));
+        const { GitIgnoreGenerator: GitIgnoreGenerator2 } = await Promise.resolve().then(() => (init_gitignore_generator(), gitignore_generator_exports));
+        const { ReadmeGenerator: ReadmeGenerator2 } = await Promise.resolve().then(() => (init_readme_generator2(), readme_generator_exports2));
+        const { RegistryGenerator: RegistryGenerator3 } = await Promise.resolve().then(() => (init_registry_generator(), registry_generator_exports));
+        const { TsconfigGenerator: TsconfigGenerator2 } = await Promise.resolve().then(() => (init_tsconfig_generator2(), tsconfig_generator_exports2));
+        generators.push(new PackageJsonCoreGenerator2(this._fileService));
+        generators.push(new BootstrapGenerator3(this._fileService));
+        generators.push(new EnvGenerator2(this._fileService));
+        generators.push(new GitIgnoreGenerator2(this._fileService));
+        generators.push(new ReadmeGenerator2(this._fileService));
+        generators.push(new RegistryGenerator3(this._fileService));
+        generators.push(new TsconfigGenerator2(this._fileService));
+        if (options.database !== CORE_CONSTANTS.NONE) {
+          if (options.database === CORE_CONSTANTS.DRIZZLE) {
+            const { DrizzleGenerator: DrizzleGenerator2 } = await Promise.resolve().then(() => (init_drizzle_generator(), drizzle_generator_exports));
+            generators.push(new DrizzleGenerator2(this._fileService));
+          } else if (options.database === CORE_CONSTANTS.SQL_LITE) {
+            const { DrizzleSqlLiteGenerator: DrizzleSqlLiteGenerator2 } = await Promise.resolve().then(() => (init_drizzle_sql_lite_generator(), drizzle_sql_lite_generator_exports));
+            generators.push(new DrizzleSqlLiteGenerator2(this._fileService));
+          }
+        }
+        if (options.targetEnv === TARGET_ENV_CONSTANTS.CONSOLE) {
+          const { MainGenerator: MainGenerator3 } = await Promise.resolve().then(() => (init_main_generator2(), main_generator_exports2));
+          generators.push(new MainGenerator3(this._fileService));
+        }
+        return generators;
+      }
+    };
+  }
+});
+
+// src/index.ts
+var import_picocolors6 = __toESM(require("picocolors"));
+
+// src/infrastructure/commands/command-runner.service.ts
+var import_node_child_process = require("child_process");
+var CommandRunner = class {
+  async run(command, args, cwd, isWin = false) {
+    return new Promise((resolve2, reject) => {
+      const cmd = isWin ? `${command}.cmd` : command;
+      const child = (0, import_node_child_process.spawn)(cmd, args, {
+        cwd,
+        stdio: "inherit",
+        shell: false
+      });
+      child.on("error", (error) => {
+        reject(new Error(`Error during execution of the command ${command}: ${error.message}`));
+      });
+      child.on("close", (code) => {
+        if (code === 0) resolve2();
+        else reject(new Error(`Command ${command} failed with code ${code}`));
+      });
+    });
+  }
+};
+
+// src/infrastructure/commands/generate.command.ts
+var import_picocolors = __toESM(require("picocolors"));
+init_shared();
+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 });
+    await (0, import_promises.writeFile)(filePath, content, "utf8");
+  }
+};
+
+// src/infrastructure/commands/generate.command.ts
+var GenerateCommandQuery = class {
+  name = "generate";
+  aliases = ["g"];
+  async execute(args) {
+    const type = args[0];
+    const componentName = args[1];
+    const isCore = args.includes("--core");
+    const isVue = args.includes("--vue");
+    if (Guards.isNullOrEmpty(type) || Guards.isNullOrEmpty(componentName)) {
+      throw new Error(`Invalid syntax. Usage: xeno-js g [command | query] <Name> [--core | --vue]`);
+    }
+    let outputPath = void 0;
+    const outputIndex = args.findIndex((arg) => arg === "--output" || arg === "-o" || arg === "--o");
+    if (outputIndex !== -1 && args.length > outputIndex + 1) {
+      outputPath = args[outputIndex + 1];
+    }
+    const targetDir = process.cwd();
+    const fileService = new FileUtils();
+    if (isCore || !isVue) {
+      const cqrsType = type === COMMAND_CONSTANTS.COMMAND ? COMMAND_CONSTANTS.COMMAND : COMMAND_CONSTANTS.QUERY;
+      const { CqrsGenerator: CqrsGenerator2 } = await Promise.resolve().then(() => (init_cqrs_generator(), cqrs_generator_exports));
+      const generator = new CqrsGenerator2(fileService);
+      await generator.generate(targetDir, componentName, cqrsType, outputPath);
+      console.info(import_picocolors.default.green(`
+  Successfully generated ${type} component '${componentName}'!`));
+    } else if (isVue) {
+      const cqrsType = type === COMMAND_CONSTANTS.COMMAND ? COMMAND_CONSTANTS.COMMAND : COMMAND_CONSTANTS.QUERY;
+      const { CqrsVueGenerator: CqrsVueGenerator2 } = await Promise.resolve().then(() => (init_cqrs_generator2(), cqrs_generator_exports2));
+      const generator = new CqrsVueGenerator2(fileService);
+      await generator.generate(targetDir, componentName, cqrsType, outputPath);
+      console.info(
+        import_picocolors.default.green(`
+\u2705 Successfully generated Vue ${type} component '${componentName}'!`)
+      );
+    } else {
+      throw new Error(`Unsupported generator type: '${type}'. Use 'command' or 'query'.`);
+    }
+  }
+};
+
+// src/infrastructure/commands/help.command.ts
+var import_picocolors2 = __toESM(require("picocolors"));
+init_shared();
+var HelpCommand = class {
+  get name() {
+    return COMMAND_CONSTANTS.HELP;
+  }
+  get aliases() {
+    return [ARGS_CONSTANTS.HELP, "-h"];
+  }
+  async execute() {
+    console.info(import_picocolors2.default.greenBright("\n\u{1F680} Xeno CLI - Usage Guide\n"));
+    console.info(import_picocolors2.default.bold(import_picocolors2.default.blue("1. Create a new project:")));
+    console.info(`  xeno-js new ${import_picocolors2.default.yellow("<name>")} ${import_picocolors2.default.cyan("[--vue | --core]")}`);
+    console.info(`  ${import_picocolors2.default.gray("\u2022")} ${import_picocolors2.default.yellow("<name>")}: The name of your project directory.`);
+    console.info(
+      `  ${import_picocolors2.default.gray("\u2022")} ${import_picocolors2.default.cyan("[--vue | --core]")}: Project type. ${import_picocolors2.default.gray("(Default: --core)")}`
+    );
+    console.info(`    - ${import_picocolors2.default.cyan("--core")}: Initializes a Backend project (Node.js/TS).`);
+    console.info(`    - ${import_picocolors2.default.cyan("--vue")}: Initializes a Frontend project (Vue.js).
+`);
+    console.info(import_picocolors2.default.bold(import_picocolors2.default.blue("2. Generate CQRS components:")));
+    console.info(
+      `  xeno-js generate ${import_picocolors2.default.magenta("<type>")} ${import_picocolors2.default.yellow("<Name>")} ${import_picocolors2.default.cyan("[--vue | --core]")} ${import_picocolors2.default.green("[--output <path>]")}`
+    );
+    console.info(
+      `  ${import_picocolors2.default.gray("\u2022")} ${import_picocolors2.default.magenta("<type>")}: Component type to generate (${import_picocolors2.default.magenta("command")} | ${import_picocolors2.default.magenta("query")}).`
+    );
+    console.info(
+      `  ${import_picocolors2.default.gray("\u2022")} ${import_picocolors2.default.yellow("<Name>")}: The name of the component (e.g., UserCreate).`
+    );
+    console.info(
+      `  ${import_picocolors2.default.gray("\u2022")} ${import_picocolors2.default.cyan("[--vue | --core]")}: Target context. ${import_picocolors2.default.gray("(Default: --core)")}`
+    );
+    console.info(
+      `    - ${import_picocolors2.default.cyan("--core")}: Generates Controller, Handler, Command/Query, Module, and Zod/DB schemas.`
+    );
+    console.info(
+      `    - ${import_picocolors2.default.cyan("--vue")}: Generates frontend-specific files (Stores, Services, etc.).`
+    );
+    console.info(
+      `  ${import_picocolors2.default.gray("\u2022")} ${import_picocolors2.default.green("[--output | -o]")}: Custom destination path inside 'src/'. ${import_picocolors2.default.gray("(Default: src/<name-in-lowercase>)")}`
+    );
+    console.info(
+      `  ${import_picocolors2.default.gray("Alias:")} ${import_picocolors2.default.gray("xeno-js g <type> <Name> [--vue | --core] [-o | --o <path>]")}
+`
+    );
+    console.info(import_picocolors2.default.bold(import_picocolors2.default.blue("3. Help:")));
+    console.info(`  xeno-js --help     ${import_picocolors2.default.gray("Displays this guide.")}`);
+    console.info(`  ${import_picocolors2.default.gray("Alias:")} ${import_picocolors2.default.gray("xeno-js --h | -h")}
+`);
+    console.info(import_picocolors2.default.bold(import_picocolors2.default.blue("Documentation:")));
+    console.info(`  ${import_picocolors2.default.underline("https://www.xeno-js.it")}
+`);
+  }
+};
+
+// src/infrastructure/commands/new-project.command.ts
+var import_picocolors4 = __toESM(require("picocolors"));
+
+// src/infrastructure/bootstrap/bootstrapper.ts
+var import_promises3 = require("fs/promises");
+var import_node_path7 = require("path");
+var import_picocolors3 = __toESM(require("picocolors"));
+var Bootstrapper = class {
+  constructor(_generators) {
+    this._generators = _generators;
+  }
+  _generators;
+  async run(projectPath, options) {
+    console.info(import_picocolors3.default.cyan("\n\u{1F680} Initializing scaffolding..."));
+    const absolutePath = (0, import_node_path7.resolve)(process.cwd(), projectPath);
+    await (0, import_promises3.mkdir)(absolutePath, { recursive: true });
+    for (const generator of this._generators) {
+      try {
+        await generator.generate(absolutePath, options);
+      } catch (error) {
+        console.error(import_picocolors3.default.red(`
+\u274C Error during execution of ${generator.constructor.name}`));
+        throw error;
+      }
+    }
+    console.info(import_picocolors3.default.green("\n\u2728 Scaffolding completed succesfully!"));
+  }
+};
+
+// src/infrastructure/commands/new-project.command.ts
+var NewProjectCommand = class {
+  name = "new";
+  aliases = [];
+  async execute(args) {
+    const targetDir = args.find((arg) => !arg.startsWith("--")) ?? "my-xeno-app";
+    const isVue = args.includes("--vue");
+    const fileService = new FileUtils();
+    let strategy;
+    if (isVue) {
+      const { VueScaffoldStrategy: VueScaffoldStrategy2 } = await Promise.resolve().then(() => (init_vue_scaffold_strategy(), vue_scaffold_strategy_exports));
+      strategy = new VueScaffoldStrategy2(fileService);
+    } else {
+      const { CoreScaffoldStrategy: CoreScaffoldStrategy2 } = await Promise.resolve().then(() => (init_core_scaffold_strategy(), core_scaffold_strategy_exports));
+      strategy = new CoreScaffoldStrategy2(fileService);
+    }
+    const options = await strategy.promptOptions(targetDir);
+    const generators = await strategy.getGenerators(options);
+    const bootstrapper = new Bootstrapper(generators);
+    await bootstrapper.run(targetDir, options);
+    const commandRunner = new CommandRunner();
+    if (options.gitInit) {
+      console.info(import_picocolors4.default.greenBright("\n\u{1F5C2}\uFE0F Initializing Git repository..."));
+      await commandRunner.run("git", ["init"], targetDir);
+    }
+    console.info(import_picocolors4.default.greenBright("\n\u{1F4E6} Installing dependencies..."));
+    const isWin = process.platform === "win32";
+    await commandRunner.run("npm", ["install"], targetDir, isWin);
+    console.info(import_picocolors4.default.green(`
+\u2705 Project successfully created in ./${targetDir}`));
+    console.info(import_picocolors4.default.white(`
+Next steps:
+  cd ${targetDir}
+  npm run start
+`));
+  }
+};
+
+// src/infrastructure/dispatcher/dispatcher.ts
+var import_picocolors5 = __toESM(require("picocolors"));
+init_shared();
+var CliDispatcher = class {
+  _commands = /* @__PURE__ */ new Map();
+  constructor(commands) {
+    for (const command of commands) {
+      this._commands.set(command.name, command);
+      for (const alias of command.aliases) {
+        this._commands.set(alias, command);
+      }
+    }
+  }
+  async dispatch(rawArgs) {
+    const action = rawArgs[0];
+    if (!Guards.isDefined(action) || action === ARGS_CONSTANTS.HELP || action === "-h" || action === "--h") {
+      const helpCommand = this._commands.get(COMMAND_CONSTANTS.HELP);
+      await helpCommand?.execute([]);
+      return;
+    }
+    const command = this._commands.get(action);
+    if (!Guards.isDefined(command)) {
+      console.error(import_picocolors5.default.red(`
+\u274C '${action}' is not a command`));
+      console.info(
+        import_picocolors5.default.yellow(`See 'xeno-js --help' for cli usage guide or https://www.xeno-js.it for docs.
+`)
+      );
+      process.exit(1);
+    }
+    const commandArgs = rawArgs.slice(1);
+    await command.execute(commandArgs);
+  }
+};
+
+// src/infrastructure/builder/builder.ts
+var Builder = class {
+  static getDispatcher() {
+    const dispatcher = new CliDispatcher([
+      new NewProjectCommand(),
+      new GenerateCommandQuery(),
+      new HelpCommand()
+    ]);
+    return dispatcher;
+  }
+};
+
+// src/index.ts
+async function init() {
+  try {
+    const dispatcher = Builder.getDispatcher();
+    const rawArgs = process.argv.slice(2);
+    await dispatcher.dispatch(rawArgs);
+  } catch (error) {
+    console.error(import_picocolors6.default.red("\n\u274C Execution interrupted:"));
+    console.error(error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
+init().catch(console.error);
+/**
+ * @class DrizzleGenerator
+ * @description Generates the Drizzle configuration file (drizzle.config.ts) and a basic schema file (src/schema.ts) for database scaffolding.
+ * The generator is only invoked if the user has opted to include database support in their project.
+ *
+ * @author Xeno
+ * @version 1.0.0
+ * @license ISC
+ * @since 2025-09-30
+ * @link https://github.com/xeno-js/xeno-js
+ */
+/**
+ * @class CommandUtils
+ * @description Utility class for executing shell commands in a cross-platform manner.
+ *
+ * @author Xeno
+ * @version 1.0.0
+ * @license ISC
+ * @since 2025-09-30
+ * @link https://github.com/xeno-js/xeno-js
+ */
 /**
  * @function init
  * @description Initializes the scaffolding process for a new Xeno project.
@@ -16,16 +3685,4 @@ const builder_1 = require("./infrastructure/builder");
  * @since 2025-09-30
  * @link https://github.com/xeno-js/xeno-js
  */
-async function init() {
-    try {
-        const dispatcher = builder_1.Builder.getDispatcher();
-        const rawArgs = process.argv.slice(2);
-        await dispatcher.dispatch(rawArgs);
-    }
-    catch (error) {
-        console.error(picocolors_1.default.red('\n❌ Execution interrupted:'));
-        console.error(error instanceof Error ? error.message : error);
-        process.exit(1);
-    }
-}
-init().catch(console.error);
+//# sourceMappingURL=index.js.map