@hexaijs/plugin-contracts-generator 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,97 +1,2744 @@
-"use strict";
-/**
- * Contracts Generator
- *
- * Extract Domain Events and Commands from TypeScript source code using decorators.
- *
- * @example
- * ```typescript
- * import { extract } from '@hexaijs/plugin-contracts-generator';
- *
- * const result = await extract({
- *   sourceDir: 'packages',
- *   outputDir: 'packages/contracts',
- * });
- *
- * console.log(`Extracted ${result.events.length} events and ${result.commands.length} commands`);
- * ```
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cliPlugin = exports.ContractsPipeline = exports.noopLogger = exports.ConsoleLogger = exports.nodeFileSystem = exports.ReexportGenerator = exports.RegistryGenerator = exports.ModuleResolutionError = exports.ResolutionError = exports.JsonParseError = exports.ParseError = exports.FileWriteError = exports.FileReadError = exports.FileNotFoundError = exports.FileSystemError = exports.TsconfigLoadError = exports.ConfigLoadError = exports.ConfigurationError = exports.MessageParserError = exports.ConfigLoader = exports.TsconfigLoader = exports.FileCopier = exports.FileGraphResolver = exports.Parser = exports.Scanner = exports.PublicQuery = exports.PublicCommand = exports.PublicEvent = exports.isCommand = exports.isDomainEvent = exports.isFunctionType = exports.isTupleType = exports.isLiteralType = exports.isReferenceType = exports.isIntersectionType = exports.isUnionType = exports.isObjectType = exports.isArrayType = exports.isPrimitiveType = void 0;
-exports.processContext = processContext;
-var types_1 = require("./domain/types");
-Object.defineProperty(exports, "isPrimitiveType", { enumerable: true, get: function () { return types_1.isPrimitiveType; } });
-Object.defineProperty(exports, "isArrayType", { enumerable: true, get: function () { return types_1.isArrayType; } });
-Object.defineProperty(exports, "isObjectType", { enumerable: true, get: function () { return types_1.isObjectType; } });
-Object.defineProperty(exports, "isUnionType", { enumerable: true, get: function () { return types_1.isUnionType; } });
-Object.defineProperty(exports, "isIntersectionType", { enumerable: true, get: function () { return types_1.isIntersectionType; } });
-Object.defineProperty(exports, "isReferenceType", { enumerable: true, get: function () { return types_1.isReferenceType; } });
-Object.defineProperty(exports, "isLiteralType", { enumerable: true, get: function () { return types_1.isLiteralType; } });
-Object.defineProperty(exports, "isTupleType", { enumerable: true, get: function () { return types_1.isTupleType; } });
-Object.defineProperty(exports, "isFunctionType", { enumerable: true, get: function () { return types_1.isFunctionType; } });
-Object.defineProperty(exports, "isDomainEvent", { enumerable: true, get: function () { return types_1.isDomainEvent; } });
-Object.defineProperty(exports, "isCommand", { enumerable: true, get: function () { return types_1.isCommand; } });
-var decorators_1 = require("./decorators");
-Object.defineProperty(exports, "PublicEvent", { enumerable: true, get: function () { return decorators_1.PublicEvent; } });
-Object.defineProperty(exports, "PublicCommand", { enumerable: true, get: function () { return decorators_1.PublicCommand; } });
-Object.defineProperty(exports, "PublicQuery", { enumerable: true, get: function () { return decorators_1.PublicQuery; } });
-var scanner_1 = require("./scanner");
-Object.defineProperty(exports, "Scanner", { enumerable: true, get: function () { return scanner_1.Scanner; } });
-var parser_1 = require("./parser");
-Object.defineProperty(exports, "Parser", { enumerable: true, get: function () { return parser_1.Parser; } });
-var file_graph_resolver_1 = require("./file-graph-resolver");
-Object.defineProperty(exports, "FileGraphResolver", { enumerable: true, get: function () { return file_graph_resolver_1.FileGraphResolver; } });
-var file_copier_1 = require("./file-copier");
-Object.defineProperty(exports, "FileCopier", { enumerable: true, get: function () { return file_copier_1.FileCopier; } });
-var tsconfig_loader_1 = require("./tsconfig-loader");
-Object.defineProperty(exports, "TsconfigLoader", { enumerable: true, get: function () { return tsconfig_loader_1.TsconfigLoader; } });
-var config_loader_1 = require("./config-loader");
-Object.defineProperty(exports, "ConfigLoader", { enumerable: true, get: function () { return config_loader_1.ConfigLoader; } });
-var errors_1 = require("./errors");
-Object.defineProperty(exports, "MessageParserError", { enumerable: true, get: function () { return errors_1.MessageParserError; } });
-Object.defineProperty(exports, "ConfigurationError", { enumerable: true, get: function () { return errors_1.ConfigurationError; } });
-Object.defineProperty(exports, "ConfigLoadError", { enumerable: true, get: function () { return errors_1.ConfigLoadError; } });
-Object.defineProperty(exports, "TsconfigLoadError", { enumerable: true, get: function () { return errors_1.TsconfigLoadError; } });
-Object.defineProperty(exports, "FileSystemError", { enumerable: true, get: function () { return errors_1.FileSystemError; } });
-Object.defineProperty(exports, "FileNotFoundError", { enumerable: true, get: function () { return errors_1.FileNotFoundError; } });
-Object.defineProperty(exports, "FileReadError", { enumerable: true, get: function () { return errors_1.FileReadError; } });
-Object.defineProperty(exports, "FileWriteError", { enumerable: true, get: function () { return errors_1.FileWriteError; } });
-Object.defineProperty(exports, "ParseError", { enumerable: true, get: function () { return errors_1.ParseError; } });
-Object.defineProperty(exports, "JsonParseError", { enumerable: true, get: function () { return errors_1.JsonParseError; } });
-Object.defineProperty(exports, "ResolutionError", { enumerable: true, get: function () { return errors_1.ResolutionError; } });
-Object.defineProperty(exports, "ModuleResolutionError", { enumerable: true, get: function () { return errors_1.ModuleResolutionError; } });
-var registry_generator_1 = require("./registry-generator");
-Object.defineProperty(exports, "RegistryGenerator", { enumerable: true, get: function () { return registry_generator_1.RegistryGenerator; } });
-var reexport_generator_1 = require("./reexport-generator");
-Object.defineProperty(exports, "ReexportGenerator", { enumerable: true, get: function () { return reexport_generator_1.ReexportGenerator; } });
-const file_system_1 = require("./file-system");
-const logger_1 = require("./logger");
-const pipeline_1 = require("./pipeline");
-var file_system_2 = require("./file-system");
-Object.defineProperty(exports, "nodeFileSystem", { enumerable: true, get: function () { return file_system_2.nodeFileSystem; } });
-var logger_2 = require("./logger");
-Object.defineProperty(exports, "ConsoleLogger", { enumerable: true, get: function () { return logger_2.ConsoleLogger; } });
-Object.defineProperty(exports, "noopLogger", { enumerable: true, get: function () { return logger_2.noopLogger; } });
-var pipeline_2 = require("./pipeline");
-Object.defineProperty(exports, "ContractsPipeline", { enumerable: true, get: function () { return pipeline_2.ContractsPipeline; } });
-async function processContext(options) {
-    const { contextName, sourceDir, outputDir, pathAliasRewrites, tsconfigPath, responseNamingConventions, removeDecorators, messageTypes, fileSystem = file_system_1.nodeFileSystem, logger = logger_1.noopLogger, } = options;
-    const pipeline = await pipeline_1.ContractsPipeline.create({
-        tsconfigPath,
-        responseNamingConventions,
+import 'reflect-metadata';
+import { glob } from 'glob';
+import { readFile, readdir, writeFile, mkdir, access, stat } from 'fs/promises';
+import { constants } from 'fs';
+import * as ts6 from 'typescript';
+import ts6__default from 'typescript';
+import * as path3 from 'path';
+import path3__default, { resolve, dirname, basename, relative, join } from 'path';
+import { minimatch } from 'minimatch';
+import { fileURLToPath } from 'url';
+
+// src/domain/types.ts
+var DEFAULT_DECORATOR_NAMES = {
+  event: "PublicEvent",
+  command: "PublicCommand",
+  query: "PublicQuery"
+};
+function mergeDecoratorNames(partial) {
+  return {
+    ...DEFAULT_DECORATOR_NAMES,
+    ...partial
+  };
+}
+function isPrimitiveType(type) {
+  return type.kind === "primitive";
+}
+function isArrayType(type) {
+  return type.kind === "array";
+}
+function isObjectType(type) {
+  return type.kind === "object";
+}
+function isUnionType(type) {
+  return type.kind === "union";
+}
+function isIntersectionType(type) {
+  return type.kind === "intersection";
+}
+function isReferenceType(type) {
+  return type.kind === "reference";
+}
+function isLiteralType(type) {
+  return type.kind === "literal";
+}
+function isTupleType(type) {
+  return type.kind === "tuple";
+}
+function isFunctionType(type) {
+  return type.kind === "function";
+}
+function isDomainEvent(message) {
+  return message.messageType === "event";
+}
+function isCommand(message) {
+  return message.messageType === "command";
+}
+var PUBLIC_EVENT_METADATA = /* @__PURE__ */ Symbol("publicEvent");
+var PUBLIC_COMMAND_METADATA = /* @__PURE__ */ Symbol("publicCommand");
+var PUBLIC_QUERY_METADATA = /* @__PURE__ */ Symbol("publicQuery");
+function PublicEvent(options = {}) {
+  return (target) => {
+    Reflect.defineMetadata(PUBLIC_EVENT_METADATA, options, target);
+    return target;
+  };
+}
+function PublicCommand(options = {}) {
+  return (target) => {
+    Reflect.defineMetadata(PUBLIC_COMMAND_METADATA, options, target);
+    return target;
+  };
+}
+function PublicQuery(options = {}) {
+  return (target) => {
+    Reflect.defineMetadata(PUBLIC_QUERY_METADATA, options, target);
+    return target;
+  };
+}
+
+// src/errors.ts
+var MessageParserError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "MessageParserError";
+  }
+};
+var ConfigurationError = class extends MessageParserError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ConfigurationError";
+  }
+};
+var ConfigLoadError = class extends ConfigurationError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ConfigLoadError";
+  }
+};
+var FileSystemError = class extends MessageParserError {
+  path;
+  constructor(message, path5, options) {
+    super(message, options);
+    this.name = "FileSystemError";
+    this.path = path5;
+  }
+};
+var FileNotFoundError = class extends FileSystemError {
+  constructor(path5, options) {
+    super(`File not found: ${path5}`, path5, options);
+    this.name = "FileNotFoundError";
+  }
+};
+var FileReadError = class extends FileSystemError {
+  constructor(path5, options) {
+    super(`Failed to read file: ${path5}`, path5, options);
+    this.name = "FileReadError";
+  }
+};
+var FileWriteError = class extends FileSystemError {
+  constructor(path5, options) {
+    super(`Failed to write file: ${path5}`, path5, options);
+    this.name = "FileWriteError";
+  }
+};
+var ParseError = class extends MessageParserError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ParseError";
+  }
+};
+var JsonParseError = class extends ParseError {
+  filePath;
+  constructor(message, filePath, options) {
+    const fullMessage = filePath ? `Failed to parse JSON in ${filePath}: ${message}` : `Failed to parse JSON: ${message}`;
+    super(fullMessage, options);
+    this.name = "JsonParseError";
+    this.filePath = filePath;
+  }
+};
+var ResolutionError = class extends MessageParserError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ResolutionError";
+  }
+};
+var ModuleResolutionError = class extends ResolutionError {
+  moduleSpecifier;
+  fromFile;
+  constructor(moduleSpecifier, fromFile, options) {
+    super(
+      `Failed to resolve module '${moduleSpecifier}' from '${fromFile}'`,
+      options
+    );
+    this.name = "ModuleResolutionError";
+    this.moduleSpecifier = moduleSpecifier;
+    this.fromFile = fromFile;
+  }
+};
+var NodeFileSystem = class {
+  async readFile(path5) {
+    return readFile(path5, "utf-8");
+  }
+  async readdir(path5) {
+    return readdir(path5);
+  }
+  async writeFile(path5, content) {
+    await writeFile(path5, content);
+  }
+  async mkdir(path5, options) {
+    await mkdir(path5, options);
+  }
+  async exists(path5) {
+    try {
+      await access(path5, constants.F_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async stat(path5) {
+    return stat(path5);
+  }
+};
+var nodeFileSystem = new NodeFileSystem();
+
+// src/scanner.ts
+var DEFAULT_EXCLUDE_PATTERNS = [
+  "**/node_modules/**",
+  "**/dist/**",
+  "**/*.d.ts",
+  "**/*.test.ts",
+  "**/*.spec.ts"
+];
+var Scanner = class {
+  exclude;
+  fs;
+  decoratorPatterns;
+  constructor(options = {}) {
+    this.exclude = options.exclude ?? DEFAULT_EXCLUDE_PATTERNS;
+    this.fs = options.fileSystem ?? nodeFileSystem;
+    const names = mergeDecoratorNames(options.decoratorNames);
+    const messageTypes = options.messageTypes ?? ["event", "command", "query"];
+    this.decoratorPatterns = messageTypes.map((type) => {
+      const decoratorName = names[type];
+      return `@${decoratorName}(`;
+    });
+  }
+  async scan(sourceDir) {
+    const files = await glob(`${sourceDir}/**/*.ts`, {
+      ignore: this.exclude
+    });
+    const result = [];
+    for (const file of files) {
+      let content;
+      try {
+        content = await this.fs.readFile(file);
+      } catch (error) {
+        throw new FileReadError(file, { cause: error });
+      }
+      if (this.containsPublicDecorator(content)) {
+        result.push(file);
+      }
+    }
+    return result;
+  }
+  containsPublicDecorator(content) {
+    return this.decoratorPatterns.some((pattern) => content.includes(pattern));
+  }
+};
+function parseTypeNode(typeNode) {
+  if (typeNode.kind === ts6.SyntaxKind.StringKeyword) {
+    return { kind: "primitive", name: "string" };
+  }
+  if (typeNode.kind === ts6.SyntaxKind.NumberKeyword) {
+    return { kind: "primitive", name: "number" };
+  }
+  if (typeNode.kind === ts6.SyntaxKind.BooleanKeyword) {
+    return { kind: "primitive", name: "boolean" };
+  }
+  if (ts6.isArrayTypeNode(typeNode)) {
+    const elementType = parseTypeNode(typeNode.elementType);
+    return { kind: "array", elementType };
+  }
+  if (ts6.isTypeReferenceNode(typeNode)) {
+    const name = typeNode.typeName.getText();
+    const typeArguments = typeNode.typeArguments ? typeNode.typeArguments.map((t) => parseTypeNode(t)) : void 0;
+    return { kind: "reference", name, typeArguments };
+  }
+  if (ts6.isIntersectionTypeNode(typeNode)) {
+    const types = typeNode.types.map((t) => parseTypeNode(t));
+    return { kind: "intersection", types };
+  }
+  if (ts6.isUnionTypeNode(typeNode)) {
+    const types = typeNode.types.map((t) => parseTypeNode(t));
+    return { kind: "union", types };
+  }
+  if (ts6.isTypeLiteralNode(typeNode)) {
+    const fields = extractFieldsFromMembers(typeNode.members);
+    return { kind: "object", fields };
+  }
+  return { kind: "reference", name: typeNode.getText() };
+}
+function extractFieldsFromMembers(members) {
+  const fields = [];
+  for (const member of members) {
+    if (ts6.isPropertySignature(member) && member.name) {
+      const fieldName = member.name.getText();
+      const fieldType = member.type ? parseTypeNode(member.type) : { kind: "primitive", name: "any" };
+      const optional = !!member.questionToken;
+      const readonly = member.modifiers?.some(
+        (m) => m.kind === ts6.SyntaxKind.ReadonlyKeyword
+      ) ?? false;
+      fields.push({
+        name: fieldName,
+        type: fieldType,
+        optional,
+        readonly
+      });
+    }
+  }
+  return fields;
+}
+function hasDecorator(node, decoratorName) {
+  const decorators = ts6.getDecorators(node);
+  if (!decorators) return false;
+  return decorators.some((decorator) => {
+    if (ts6.isCallExpression(decorator.expression)) {
+      const expr = decorator.expression.expression;
+      if (ts6.isIdentifier(expr)) {
+        return expr.text === decoratorName;
+      }
+    }
+    return false;
+  });
+}
+function getDecoratorOptions(node, decoratorName) {
+  const decorators = ts6.getDecorators(node);
+  if (!decorators) return void 0;
+  for (const decorator of decorators) {
+    if (!ts6.isCallExpression(decorator.expression)) continue;
+    const expr = decorator.expression.expression;
+    if (!ts6.isIdentifier(expr) || expr.text !== decoratorName) continue;
+    const args = decorator.expression.arguments;
+    if (args.length === 0) return {};
+    const firstArg = args[0];
+    if (!ts6.isObjectLiteralExpression(firstArg)) return {};
+    const options = {};
+    for (const prop of firstArg.properties) {
+      if (!ts6.isPropertyAssignment(prop)) continue;
+      if (!ts6.isIdentifier(prop.name)) continue;
+      const propName = prop.name.text;
+      if (propName === "response" && ts6.isStringLiteral(prop.initializer)) {
+        options.response = prop.initializer.text;
+      } else if (propName === "context" && ts6.isStringLiteral(prop.initializer)) {
+        options.context = prop.initializer.text;
+      }
+    }
+    return options;
+  }
+  return void 0;
+}
+function hasExportModifier(node) {
+  const modifiers = ts6.canHaveModifiers(node) ? ts6.getModifiers(node) : void 0;
+  return modifiers?.some((m) => m.kind === ts6.SyntaxKind.ExportKeyword) ?? false;
+}
+function extractClassSourceText(node, sourceCode) {
+  const fullStart = node.getFullStart();
+  const end = node.getEnd();
+  let sourceText = sourceCode.slice(fullStart, end);
+  sourceText = sourceText.replace(/^\s*\n/, "");
+  return sourceText;
+}
+function getBaseClassName(node) {
+  if (!node.heritageClauses) return void 0;
+  for (const clause of node.heritageClauses) {
+    if (clause.token === ts6.SyntaxKind.ExtendsKeyword) {
+      const firstType = clause.types[0];
+      if (firstType && ts6.isExpressionWithTypeArguments(firstType)) {
+        const expr = firstType.expression;
+        if (ts6.isIdentifier(expr)) {
+          return expr.text;
+        }
+      }
+    }
+  }
+  return void 0;
+}
+function isExternalModule(moduleSpecifier) {
+  return !moduleSpecifier.startsWith(".");
+}
+function extractImports(sourceFile) {
+  const imports = [];
+  ts6.forEachChild(sourceFile, (node) => {
+    if (ts6.isImportDeclaration(node) && node.importClause) {
+      const moduleSpecifier = node.moduleSpecifier.text;
+      const isExternal = isExternalModule(moduleSpecifier);
+      const isTypeOnly = node.importClause.isTypeOnly ?? false;
+      const importedNames = extractImportedNames(node.importClause);
+      if (importedNames.length > 0) {
+        imports.push({
+          names: importedNames,
+          source: moduleSpecifier,
+          isTypeOnly,
+          isExternal
+        });
+      }
+    }
+  });
+  return imports;
+}
+function extractImportedNames(importClause) {
+  const names = [];
+  if (importClause.name) {
+    names.push(importClause.name.text);
+  }
+  if (importClause.namedBindings) {
+    if (ts6.isNamedImports(importClause.namedBindings)) {
+      for (const element of importClause.namedBindings.elements) {
+        names.push(element.name.text);
+      }
+    }
+  }
+  return names;
+}
+
+// src/parser.ts
+var PAYLOAD_TYPE_ARGUMENT_INDEX = 0;
+function buildDecoratorMappings(decoratorNames) {
+  return [
+    { decorator: decoratorNames.event, messageType: "event" },
+    { decorator: decoratorNames.command, messageType: "command" },
+    { decorator: decoratorNames.query, messageType: "query" }
+  ];
+}
+function extractTypeParameterNames(typeParameters) {
+  if (!typeParameters) return void 0;
+  return typeParameters.map((tp) => tp.name.text);
+}
+var Parser = class {
+  decoratorMappings;
+  responseNamingConventions;
+  messageTypes;
+  constructor(options = {}) {
+    const names = mergeDecoratorNames(options.decoratorNames);
+    this.decoratorMappings = buildDecoratorMappings(names);
+    this.responseNamingConventions = options.responseNamingConventions ?? [];
+    this.messageTypes = options.messageTypes;
+  }
+  parse(sourceCode, sourceFileInfo) {
+    const tsSourceFile = ts6__default.createSourceFile(
+      sourceFileInfo.absolutePath,
+      sourceCode,
+      ts6__default.ScriptTarget.Latest,
+      true
+    );
+    const events = [];
+    const commands = [];
+    const queries = [];
+    const typeDefinitions = [];
+    const messageCollectors = {
+      event: (m) => events.push(m),
+      command: (m) => commands.push(m),
+      query: (m) => queries.push(m)
+    };
+    const visit = (node) => {
+      if (ts6__default.isClassDeclaration(node) && node.name) {
+        this.collectMessagesFromClass(node, sourceCode, tsSourceFile, sourceFileInfo, messageCollectors);
+      }
+      if (ts6__default.isTypeAliasDeclaration(node) && node.name) {
+        typeDefinitions.push(this.extractTypeDefinition(node, sourceFileInfo));
+      }
+      if (ts6__default.isInterfaceDeclaration(node) && node.name) {
+        typeDefinitions.push(this.extractInterfaceDefinition(node, sourceFileInfo));
+      }
+      ts6__default.forEachChild(node, visit);
+    };
+    visit(tsSourceFile);
+    this.applyNamingConventionMatching(commands, typeDefinitions);
+    this.applyNamingConventionMatching(queries, typeDefinitions);
+    return { events, commands, queries, typeDefinitions };
+  }
+  collectMessagesFromClass(node, sourceCode, tsSourceFile, sourceFileInfo, collectors) {
+    for (const { decorator, messageType } of this.decoratorMappings) {
+      if (!hasDecorator(node, decorator)) continue;
+      if (this.messageTypes && !this.messageTypes.includes(messageType)) continue;
+      const message = this.buildMessage(node, sourceCode, tsSourceFile, sourceFileInfo, messageType, decorator);
+      collectors[messageType](message);
+    }
+  }
+  applyNamingConventionMatching(messages, typeDefinitions) {
+    for (const message of messages) {
+      const hasExplicitResultType = Boolean(message.resultType);
+      if (hasExplicitResultType) continue;
+      const matchedTypeName = this.findMatchingResponseType(message.name, typeDefinitions);
+      if (matchedTypeName) {
+        message.resultType = {
+          kind: "reference",
+          name: matchedTypeName
+        };
+      }
+    }
+  }
+  findMatchingResponseType(messageName, typeDefinitions) {
+    for (const convention of this.responseNamingConventions) {
+      const hasSuffix = messageName.endsWith(convention.messageSuffix);
+      if (!hasSuffix) continue;
+      const messagePrefix = messageName.slice(0, -convention.messageSuffix.length);
+      const expectedResponseName = messagePrefix + convention.responseSuffix;
+      const matchingType = typeDefinitions.find((t) => t.name === expectedResponseName);
+      if (matchingType) return matchingType.name;
+    }
+    return void 0;
+  }
+  buildMessage(node, sourceCode, tsSourceFile, sourceFileInfo, messageType, decoratorName) {
+    const extracted = this.extractMessageDetails(node, sourceCode, tsSourceFile);
+    const decoratorOptions = getDecoratorOptions(node, decoratorName);
+    const baseMessage = {
+      name: node.name.text,
+      messageType,
+      sourceFile: sourceFileInfo,
+      fields: extracted.fields,
+      payloadType: extracted.payloadType,
+      sourceText: extracted.sourceText,
+      imports: extracted.imports,
+      baseClass: extracted.baseClass
+    };
+    const explicitResponseName = decoratorOptions?.response;
+    const supportsResultType = messageType === "command" || messageType === "query";
+    if (!supportsResultType || !explicitResponseName) {
+      return baseMessage;
+    }
+    return {
+      ...baseMessage,
+      resultType: {
+        kind: "reference",
+        name: explicitResponseName
+      }
+    };
+  }
+  extractMessageDetails(node, sourceCode, tsSourceFile) {
+    const { fields, payloadType } = this.extractPayload(node);
+    const sourceText = extractClassSourceText(node, sourceCode);
+    const imports = extractImports(tsSourceFile);
+    const baseClass = getBaseClassName(node);
+    return {
+      fields,
+      payloadType,
+      sourceText,
+      imports,
+      baseClass
+    };
+  }
+  extractPayload(node) {
+    const emptyPayload = { fields: [] };
+    if (!node.heritageClauses) return emptyPayload;
+    const extendsClause = node.heritageClauses.find(
+      (clause) => clause.token === ts6__default.SyntaxKind.ExtendsKeyword
+    );
+    if (!extendsClause) return emptyPayload;
+    for (const type of extendsClause.types) {
+      const typeArgs = type.typeArguments;
+      if (!typeArgs || typeArgs.length === 0) continue;
+      const payloadTypeArg = typeArgs[PAYLOAD_TYPE_ARGUMENT_INDEX];
+      const extractedPayload = this.parsePayloadTypeArgument(payloadTypeArg);
+      if (extractedPayload) return extractedPayload;
+    }
+    return emptyPayload;
+  }
+  parsePayloadTypeArgument(typeArg) {
+    if (ts6__default.isTypeReferenceNode(typeArg) && ts6__default.isIdentifier(typeArg.typeName)) {
+      return {
+        fields: [],
+        payloadType: parseTypeNode(typeArg)
+      };
+    }
+    if (ts6__default.isTypeLiteralNode(typeArg)) {
+      return {
+        fields: extractFieldsFromMembers(typeArg.members)
+      };
+    }
+    if (ts6__default.isIntersectionTypeNode(typeArg)) {
+      const parsedType = parseTypeNode(typeArg);
+      return {
+        fields: this.flattenIntersectionToFields(parsedType),
+        payloadType: parsedType
+      };
+    }
+    return void 0;
+  }
+  flattenIntersectionToFields(intersection) {
+    const fields = [];
+    for (const type of intersection.types) {
+      if (type.kind === "object") {
+        fields.push(...type.fields);
+      }
+    }
+    return fields;
+  }
+  extractTypeDefinition(node, sourceFileInfo) {
+    return this.buildTypeDefinition(
+      node.name.text,
+      "type",
+      sourceFileInfo,
+      parseTypeNode(node.type),
+      node.typeParameters,
+      node
+    );
+  }
+  extractInterfaceDefinition(node, sourceFileInfo) {
+    const body = {
+      kind: "object",
+      fields: extractFieldsFromMembers(node.members)
+    };
+    return this.buildTypeDefinition(
+      node.name.text,
+      "interface",
+      sourceFileInfo,
+      body,
+      node.typeParameters,
+      node
+    );
+  }
+  buildTypeDefinition(name, kind, sourceFile, body, typeParameters, node) {
+    return {
+      name,
+      kind,
+      sourceFile,
+      body,
+      typeParameters: extractTypeParameterNames(typeParameters),
+      exported: hasExportModifier(node)
+    };
+  }
+};
+var TYPESCRIPT_EXTENSIONS = [".ts", ".tsx"];
+var INDEX_FILE = "index.ts";
+var FileGraphResolver = class _FileGraphResolver {
+  contextConfig;
+  fs;
+  excludeDependencies;
+  constructor(contextConfig, fileSystem, excludeDependencies) {
+    this.contextConfig = contextConfig;
+    this.fs = fileSystem;
+    this.excludeDependencies = excludeDependencies;
+  }
+  static create(options) {
+    const fs = options.fileSystem ?? nodeFileSystem;
+    const excludeDependencies = options.excludeDependencies ?? [];
+    return new _FileGraphResolver(options.contextConfig, fs, excludeDependencies);
+  }
+  async buildGraph(entryPoints, sourceRoot) {
+    const nodes = /* @__PURE__ */ new Map();
+    const entryPointSet = new Set(entryPoints);
+    const excludedPaths = /* @__PURE__ */ new Set();
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [...entryPoints];
+    while (queue.length > 0) {
+      const filePath = queue.shift();
+      if (visited.has(filePath)) {
+        continue;
+      }
+      visited.add(filePath);
+      const imports = await this.extractImports(filePath);
+      const node = {
+        absolutePath: filePath,
+        relativePath: path3__default.relative(sourceRoot, filePath),
+        imports,
+        isEntryPoint: entryPointSet.has(filePath)
+      };
+      nodes.set(filePath, node);
+      this.queueUnvisitedLocalDependencies(imports, visited, queue, excludedPaths);
+    }
+    return {
+      nodes,
+      entryPoints: entryPointSet,
+      excludedPaths
+    };
+  }
+  async extractImports(filePath) {
+    const sourceCode = await this.readSourceFile(filePath);
+    const sourceFile = ts6__default.createSourceFile(
+      filePath,
+      sourceCode,
+      ts6__default.ScriptTarget.Latest,
+      true
+    );
+    const imports = [];
+    for (const node of sourceFile.statements) {
+      const moduleSpecifier = this.extractModuleSpecifier(node);
+      if (!moduleSpecifier) {
+        continue;
+      }
+      const resolution = await this.resolveModule(moduleSpecifier, filePath);
+      const importedNames = this.extractImportedNamesFromNode(node);
+      imports.push({
+        moduleSpecifier,
+        resolvedPath: resolution.resolvedPath,
+        isExternal: resolution.isExternal,
+        importedNames
+      });
+    }
+    return imports;
+  }
+  async readSourceFile(filePath) {
+    try {
+      return await this.fs.readFile(filePath);
+    } catch (error) {
+      throw new FileReadError(filePath, { cause: error });
+    }
+  }
+  extractModuleSpecifier(node) {
+    if (ts6__default.isImportDeclaration(node)) {
+      return node.moduleSpecifier.text;
+    }
+    if (ts6__default.isExportDeclaration(node) && node.moduleSpecifier) {
+      return node.moduleSpecifier.text;
+    }
+    return null;
+  }
+  extractImportedNamesFromNode(node) {
+    if (ts6__default.isImportDeclaration(node) && node.importClause) {
+      return extractImportedNames(node.importClause);
+    }
+    return [];
+  }
+  async resolveModule(moduleSpecifier, fromFile) {
+    if (moduleSpecifier.startsWith(".")) {
+      const resolvedPath = await this.resolveRelativeModule(
+        moduleSpecifier,
+        fromFile
+      );
+      return { resolvedPath, isExternal: false };
+    }
+    return this.contextConfig.resolvePath(moduleSpecifier);
+  }
+  queueUnvisitedLocalDependencies(imports, visited, queue, excludedPaths) {
+    const localImports = imports.filter(
+      (importInfo) => !importInfo.isExternal && importInfo.resolvedPath !== null
+    );
+    for (const importInfo of localImports) {
+      const resolvedPath = importInfo.resolvedPath;
+      if (this.shouldExclude(resolvedPath)) {
+        excludedPaths.add(resolvedPath);
+        continue;
+      }
+      if (!visited.has(resolvedPath)) {
+        queue.push(resolvedPath);
+      }
+    }
+  }
+  shouldExclude(filePath) {
+    if (this.excludeDependencies.length === 0) {
+      return false;
+    }
+    return this.excludeDependencies.some(
+      (pattern) => minimatch(filePath, pattern, { matchBase: true })
+    );
+  }
+  async resolveRelativeModule(moduleSpecifier, fromFile) {
+    const dir = path3__default.dirname(fromFile);
+    const basePath = path3__default.resolve(dir, moduleSpecifier);
+    return this.tryResolveWithExtensions(basePath);
+  }
+  async tryResolveWithExtensions(basePath) {
+    const extensionCandidates = TYPESCRIPT_EXTENSIONS.map((ext) => basePath + ext);
+    const indexCandidate = path3__default.join(basePath, INDEX_FILE);
+    const candidates = [...extensionCandidates, indexCandidate];
+    for (const candidate of candidates) {
+      if (await this.fs.exists(candidate)) {
+        return candidate;
+      }
+    }
+    return null;
+  }
+};
+var CONTRACTS_GENERATOR_MODULE = "@hexaijs/plugin-contracts-generator";
+var CONTRACT_DECORATORS = /* @__PURE__ */ new Set([
+  "PublicCommand",
+  "PublicEvent",
+  "PublicQuery"
+]);
+var TS_EXTENSION_PATTERN = /\.ts$/;
+var REQUEST_SUFFIX = "Request";
+var QUERY_SUFFIX = "Query";
+var FileCopier = class {
+  fs;
+  constructor(options = {}) {
+    this.fs = options.fileSystem ?? nodeFileSystem;
+  }
+  async copyFiles(options) {
+    const {
+      sourceRoot,
+      outputDir,
+      fileGraph,
+      pathAliasRewrites,
+      removeDecorators,
+      responseTypesToExport,
+      messageTypes,
+      decoratorNames
+    } = options;
+    const copiedFiles = [];
+    const rewrittenImports = /* @__PURE__ */ new Map();
+    const { entryContents, usedLocalImports } = await this.preprocessEntryFiles(
+      fileGraph,
+      messageTypes,
+      decoratorNames,
+      sourceRoot
+    );
+    this.expandTransitiveDependencies(usedLocalImports, fileGraph);
+    for (const node of fileGraph.nodes.values()) {
+      const content = await this.resolveNodeContent(
+        node,
+        entryContents,
+        usedLocalImports,
+        messageTypes
+      );
+      if (content === null) {
+        continue;
+      }
+      const transformedContent = this.applyTransformations(
+        content,
+        node,
+        fileGraph,
+        sourceRoot,
+        removeDecorators,
+        responseTypesToExport,
+        pathAliasRewrites
+      );
+      const outputPath = await this.writeOutputFile(
+        outputDir,
+        node.relativePath,
+        transformedContent.content
+      );
+      copiedFiles.push(outputPath);
+      if (transformedContent.rewrites.length > 0) {
+        rewrittenImports.set(outputPath, transformedContent.rewrites);
+      }
+    }
+    return { copiedFiles, rewrittenImports };
+  }
+  async preprocessEntryFiles(fileGraph, messageTypes, decoratorNames, sourceRoot) {
+    const entryContents = /* @__PURE__ */ new Map();
+    const usedLocalImports = /* @__PURE__ */ new Set();
+    if (!messageTypes?.length) {
+      return { entryContents, usedLocalImports };
+    }
+    for (const node of fileGraph.nodes.values()) {
+      if (!node.isEntryPoint) {
+        continue;
+      }
+      const rawContent = await this.readFileContent(node.absolutePath);
+      const { content: extractedContent, usedModuleSpecifiers } = this.extractSymbolsFromEntry(
+        rawContent,
+        node.absolutePath,
         messageTypes,
+        decoratorNames
+      );
+      entryContents.set(node.absolutePath, extractedContent);
+      for (const specifier of usedModuleSpecifiers) {
+        const importInfo = node.imports.find(
+          (i) => i.moduleSpecifier === specifier
+        );
+        if (importInfo?.resolvedPath && !importInfo.isExternal) {
+          usedLocalImports.add(importInfo.resolvedPath);
+        }
+      }
+    }
+    return { entryContents, usedLocalImports };
+  }
+  expandTransitiveDependencies(usedLocalImports, fileGraph) {
+    let changed = true;
+    while (changed) {
+      changed = false;
+      for (const importPath of usedLocalImports) {
+        const node = fileGraph.nodes.get(importPath);
+        if (!node) continue;
+        for (const imp of node.imports) {
+          const isUnusedLocalImport = imp.resolvedPath && !imp.isExternal && !usedLocalImports.has(imp.resolvedPath);
+          if (isUnusedLocalImport) {
+            usedLocalImports.add(imp.resolvedPath);
+            changed = true;
+          }
+        }
+      }
+    }
+  }
+  async resolveNodeContent(node, entryContents, usedLocalImports, messageTypes) {
+    if (node.isEntryPoint && messageTypes?.length) {
+      return entryContents.get(node.absolutePath) ?? await this.readFileContent(node.absolutePath);
+    }
+    const isUnusedDependency = messageTypes?.length && !usedLocalImports.has(node.absolutePath);
+    if (isUnusedDependency) {
+      return null;
+    }
+    return await this.readFileContent(node.absolutePath);
+  }
+  applyTransformations(content, node, fileGraph, sourceRoot, removeDecorators, responseTypesToExport, pathAliasRewrites) {
+    const rewrites = [];
+    let transformedContent = content;
+    transformedContent = this.processExcludedImports(
+      transformedContent,
+      node,
+      fileGraph.excludedPaths,
+      rewrites
+    );
+    transformedContent = this.processDecoratorRemoval(
+      transformedContent,
+      node.absolutePath,
+      removeDecorators,
+      rewrites
+    );
+    transformedContent = this.processTypeExports(
+      transformedContent,
+      node.absolutePath,
+      responseTypesToExport?.get(node.absolutePath),
+      rewrites
+    );
+    transformedContent = this.processInternalPathAliases(
+      transformedContent,
+      node,
+      fileGraph,
+      sourceRoot,
+      rewrites
+    );
+    transformedContent = this.processExternalPathAliases(
+      transformedContent,
+      pathAliasRewrites,
+      rewrites
+    );
+    return { content: transformedContent, rewrites };
+  }
+  generateBarrelExport(copiedFiles, outputDir) {
+    const lines = [];
+    for (const filePath of copiedFiles) {
+      const relativePath = path3.relative(outputDir, filePath);
+      lines.push(this.createExportStatement(relativePath));
+    }
+    return lines.join("\n");
+  }
+  async readFileContent(absolutePath) {
+    try {
+      return await this.fs.readFile(absolutePath);
+    } catch (error) {
+      throw new FileReadError(absolutePath, { cause: error });
+    }
+  }
+  async writeOutputFile(outputDir, relativePath, content) {
+    const outputPath = path3.join(outputDir, relativePath);
+    const outputDirPath = path3.dirname(outputPath);
+    await this.fs.mkdir(outputDirPath, { recursive: true });
+    try {
+      await this.fs.writeFile(outputPath, content);
+    } catch (error) {
+      throw new FileWriteError(outputPath, { cause: error });
+    }
+    return outputPath;
+  }
+  processExcludedImports(content, node, excludedPaths, rewrites) {
+    if (excludedPaths.size === 0) {
+      return content;
+    }
+    const excludedResult = this.removeExcludedImports(
+      content,
+      node,
+      excludedPaths
+    );
+    rewrites.push(...excludedResult.changes);
+    return excludedResult.content;
+  }
+  processDecoratorRemoval(content, filePath, removeDecorators, rewrites) {
+    if (!removeDecorators) {
+      return content;
+    }
+    const decoratorResult = this.removeContractDecorators(
+      content,
+      filePath
+    );
+    rewrites.push(...decoratorResult.changes);
+    return decoratorResult.content;
+  }
+  processTypeExports(content, filePath, typesToExport, rewrites) {
+    if (!typesToExport || typesToExport.length === 0) {
+      return content;
+    }
+    const exportResult = this.addExportToTypes(
+      content,
+      filePath,
+      typesToExport
+    );
+    rewrites.push(...exportResult.changes);
+    return exportResult.content;
+  }
+  processInternalPathAliases(content, node, fileGraph, sourceRoot, rewrites) {
+    const internalResult = this.rewriteInternalPathAliases(
+      content,
+      node,
+      fileGraph,
+      sourceRoot
+    );
+    rewrites.push(...internalResult.rewrites);
+    return internalResult.content;
+  }
+  processExternalPathAliases(content, pathAliasRewrites, rewrites) {
+    if (!pathAliasRewrites) {
+      return content;
+    }
+    const aliasResult = this.applyPathAliasRewrites(
+      content,
+      pathAliasRewrites
+    );
+    rewrites.push(...aliasResult.rewrites);
+    return aliasResult.content;
+  }
+  createExportStatement(relativePath) {
+    const exportPath = "./" + relativePath.replace(TS_EXTENSION_PATTERN, "");
+    return `export * from '${exportPath}'`;
+  }
+  rewriteInternalPathAliases(content, node, fileGraph, sourceRoot) {
+    let transformedContent = content;
+    const appliedRewrites = [];
+    for (const importInfo of node.imports) {
+      if (this.isExternalOrRelativeImport(importInfo)) {
+        continue;
+      }
+      const targetNode = this.resolveInternalImport(
+        importInfo,
+        fileGraph
+      );
+      if (!targetNode) {
+        continue;
+      }
+      const relativePath = this.computeRelativePath(
+        node.relativePath,
+        targetNode.relativePath
+      );
+      const rewriteResult = this.rewriteModuleSpecifier(
+        transformedContent,
+        importInfo.moduleSpecifier,
+        relativePath
+      );
+      if (rewriteResult.wasRewritten) {
+        transformedContent = rewriteResult.content;
+        appliedRewrites.push(
+          `${importInfo.moduleSpecifier} \u2192 ${relativePath}`
+        );
+      }
+    }
+    return { content: transformedContent, rewrites: appliedRewrites };
+  }
+  isExternalOrRelativeImport(importInfo) {
+    return importInfo.isExternal || importInfo.moduleSpecifier.startsWith(".");
+  }
+  resolveInternalImport(importInfo, fileGraph) {
+    if (!importInfo.resolvedPath || !fileGraph.nodes.has(importInfo.resolvedPath)) {
+      return void 0;
+    }
+    return fileGraph.nodes.get(importInfo.resolvedPath);
+  }
+  rewriteModuleSpecifier(content, originalSpecifier, newSpecifier) {
+    const importPattern = new RegExp(
+      `(from\\s+['"])${this.escapeRegex(originalSpecifier)}(['"])`,
+      "g"
+    );
+    if (!importPattern.test(content)) {
+      return { content, wasRewritten: false };
+    }
+    const rewrittenContent = content.replace(
+      importPattern,
+      `$1${newSpecifier}$2`
+    );
+    return { content: rewrittenContent, wasRewritten: true };
+  }
+  computeRelativePath(fromRelative, toRelative) {
+    const fromDir = path3.dirname(fromRelative);
+    let relativePath = path3.relative(fromDir, toRelative);
+    relativePath = relativePath.replace(TS_EXTENSION_PATTERN, "");
+    if (!relativePath.startsWith(".")) {
+      relativePath = "./" + relativePath;
+    }
+    return relativePath;
+  }
+  applyPathAliasRewrites(content, rewrites) {
+    let transformedContent = content;
+    const appliedRewrites = [];
+    for (const [from, to] of rewrites) {
+      if (transformedContent.includes(from)) {
+        transformedContent = transformedContent.replace(
+          new RegExp(this.escapeRegex(from), "g"),
+          to
+        );
+        appliedRewrites.push(`${from} \u2192 ${to}`);
+      }
+    }
+    return { content: transformedContent, rewrites: appliedRewrites };
+  }
+  escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  removeExcludedImports(content, node, excludedPaths) {
+    const excludedModuleSpecifiers = this.findExcludedModuleSpecifiers(
+      node,
+      excludedPaths
+    );
+    if (excludedModuleSpecifiers.size === 0) {
+      return { content, changes: [] };
+    }
+    const changes = Array.from(excludedModuleSpecifiers).map(
+      (specifier) => `removed import: ${specifier}`
+    );
+    const visitorFactory = this.createExcludedImportsVisitor(
+      excludedModuleSpecifiers
+    );
+    const transformedContent = this.transformSourceFile(
+      content,
+      node.absolutePath,
+      visitorFactory
+    );
+    return { content: transformedContent, changes };
+  }
+  findExcludedModuleSpecifiers(node, excludedPaths) {
+    const excludedModuleSpecifiers = /* @__PURE__ */ new Set();
+    for (const importInfo of node.imports) {
+      if (importInfo.resolvedPath && excludedPaths.has(importInfo.resolvedPath)) {
+        excludedModuleSpecifiers.add(importInfo.moduleSpecifier);
+      }
+    }
+    return excludedModuleSpecifiers;
+  }
+  createExcludedImportsVisitor(excludedModuleSpecifiers) {
+    return (context) => {
+      const visit = (node) => {
+        if (this.isImportFromExcludedModule(
+          node,
+          excludedModuleSpecifiers
+        )) {
+          return void 0;
+        }
+        if (this.isExportFromExcludedModule(
+          node,
+          excludedModuleSpecifiers
+        )) {
+          return void 0;
+        }
+        return ts6.visitEachChild(node, visit, context);
+      };
+      return visit;
+    };
+  }
+  isImportFromExcludedModule(node, excludedModules) {
+    if (!ts6.isImportDeclaration(node)) {
+      return false;
+    }
+    const moduleSpecifier = node.moduleSpecifier.text;
+    return excludedModules.has(moduleSpecifier);
+  }
+  isExportFromExcludedModule(node, excludedModules) {
+    if (!ts6.isExportDeclaration(node) || !node.moduleSpecifier) {
+      return false;
+    }
+    const moduleSpecifier = node.moduleSpecifier.text;
+    return excludedModules.has(moduleSpecifier);
+  }
+  removeContractDecorators(content, filePath) {
+    const changes = [];
+    const visitorFactory = this.createDecoratorRemovalVisitor(changes);
+    const transformedContent = this.transformSourceFile(
+      content,
+      filePath,
+      visitorFactory
+    );
+    return { content: transformedContent, changes };
+  }
+  createDecoratorRemovalVisitor(changes) {
+    return (context) => {
+      const visit = (node) => {
+        if (ts6.isImportDeclaration(node)) {
+          return this.processContractGeneratorImport(node, changes);
+        }
+        if (ts6.isClassDeclaration(node) && node.modifiers) {
+          return this.removeContractDecoratorsFromClass(
+            node,
+            changes
+          );
+        }
+        return ts6.visitEachChild(node, visit, context);
+      };
+      return visit;
+    };
+  }
+  processContractGeneratorImport(node, changes) {
+    const moduleSpecifier = node.moduleSpecifier.text;
+    const isContractGeneratorModule = moduleSpecifier === CONTRACTS_GENERATOR_MODULE || moduleSpecifier.startsWith(CONTRACTS_GENERATOR_MODULE + "/");
+    if (!isContractGeneratorModule) {
+      return node;
+    }
+    const namedBindings = node.importClause?.namedBindings;
+    if (!namedBindings || !ts6.isNamedImports(namedBindings)) {
+      return node;
+    }
+    const remainingElements = namedBindings.elements.filter(
+      (el) => !CONTRACT_DECORATORS.has(el.name.text)
+    );
+    if (remainingElements.length === 0) {
+      changes.push(`removed import: ${moduleSpecifier}`);
+      return void 0;
+    }
+    if (remainingElements.length < namedBindings.elements.length) {
+      changes.push(`removed decorators from import: ${moduleSpecifier}`);
+      return this.createImportWithFilteredBindings(
+        node,
+        remainingElements
+      );
+    }
+    return node;
+  }
+  createImportWithFilteredBindings(originalImport, remainingElements) {
+    const newNamedImports = ts6.factory.createNamedImports(remainingElements);
+    const newImportClause = ts6.factory.createImportClause(
+      originalImport.importClause.isTypeOnly,
+      originalImport.importClause.name,
+      newNamedImports
+    );
+    return ts6.factory.createImportDeclaration(
+      originalImport.modifiers,
+      newImportClause,
+      originalImport.moduleSpecifier,
+      originalImport.attributes
+    );
+  }
+  removeContractDecoratorsFromClass(node, changes) {
+    const filteredModifiers = node.modifiers.filter((modifier) => {
+      if (!ts6.isDecorator(modifier)) {
+        return true;
+      }
+      const decoratorName = this.extractDecoratorName(modifier);
+      if (decoratorName && CONTRACT_DECORATORS.has(decoratorName)) {
+        const decoratorSuffix = this.isDecoratorCallExpression(modifier) ? "()" : "";
+        changes.push(
+          `removed decorator: @${decoratorName}${decoratorSuffix}`
+        );
+        return false;
+      }
+      return true;
+    });
+    if (filteredModifiers.length === node.modifiers.length) {
+      return node;
+    }
+    return ts6.factory.createClassDeclaration(
+      filteredModifiers,
+      node.name,
+      node.typeParameters,
+      node.heritageClauses,
+      node.members
+    );
+  }
+  extractDecoratorName(decorator) {
+    const expression = decorator.expression;
+    if (ts6.isCallExpression(expression) && ts6.isIdentifier(expression.expression)) {
+      return expression.expression.text;
+    }
+    if (ts6.isIdentifier(expression)) {
+      return expression.text;
+    }
+    return void 0;
+  }
+  isDecoratorCallExpression(decorator) {
+    return ts6.isCallExpression(decorator.expression);
+  }
+  hasExportModifier(node) {
+    return node.modifiers?.some(
+      (m) => m.kind === ts6.SyntaxKind.ExportKeyword
+    ) ?? false;
+  }
+  prependExportModifier(modifiers) {
+    const exportModifier = ts6.factory.createModifier(
+      ts6.SyntaxKind.ExportKeyword
+    );
+    return modifiers ? [exportModifier, ...modifiers] : [exportModifier];
+  }
+  addExportToTypes(content, filePath, typeNames) {
+    const changes = [];
+    const typeNamesSet = new Set(typeNames);
+    const visitorFactory = this.createExportAdditionVisitor(
+      typeNamesSet,
+      changes
+    );
+    const transformedContent = this.transformSourceFile(
+      content,
+      filePath,
+      visitorFactory
+    );
+    return { content: transformedContent, changes };
+  }
+  createExportAdditionVisitor(typeNamesSet, changes) {
+    return (context) => {
+      const visit = (node) => {
+        if (ts6.isTypeAliasDeclaration(node)) {
+          return this.addExportToTypeAlias(
+            node,
+            typeNamesSet,
+            changes
+          );
+        }
+        if (ts6.isInterfaceDeclaration(node)) {
+          return this.addExportToInterface(
+            node,
+            typeNamesSet,
+            changes
+          );
+        }
+        return ts6.visitEachChild(node, visit, context);
+      };
+      return visit;
+    };
+  }
+  addExportToTypeAlias(node, typeNamesSet, changes) {
+    const typeName = node.name.text;
+    if (!typeNamesSet.has(typeName) || this.hasExportModifier(node)) {
+      return node;
+    }
+    changes.push(`added export: type ${typeName}`);
+    return ts6.factory.createTypeAliasDeclaration(
+      this.prependExportModifier(node.modifiers),
+      node.name,
+      node.typeParameters,
+      node.type
+    );
+  }
+  addExportToInterface(node, typeNamesSet, changes) {
+    const typeName = node.name.text;
+    if (!typeNamesSet.has(typeName) || this.hasExportModifier(node)) {
+      return node;
+    }
+    changes.push(`added export: interface ${typeName}`);
+    return ts6.factory.createInterfaceDeclaration(
+      this.prependExportModifier(node.modifiers),
+      node.name,
+      node.typeParameters,
+      node.heritageClauses,
+      node.members
+    );
+  }
+  transformSourceFile(content, filePath, visitorFactory) {
+    const sourceFile = ts6.createSourceFile(
+      filePath,
+      content,
+      ts6.ScriptTarget.Latest,
+      true,
+      ts6.ScriptKind.TS
+    );
+    const transformer = (context) => {
+      return (sf) => {
+        const visitor = visitorFactory(context);
+        return ts6.visitNode(sf, visitor);
+      };
+    };
+    const result = ts6.transform(sourceFile, [transformer]);
+    const transformedSourceFile = result.transformed[0];
+    const printer = ts6.createPrinter({ newLine: ts6.NewLineKind.LineFeed });
+    const transformedContent = printer.printFile(transformedSourceFile);
+    result.dispose();
+    return transformedContent;
+  }
+  extractSymbolsFromEntry(content, filePath, messageTypes, decoratorNames) {
+    const sourceFile = ts6.createSourceFile(
+      filePath,
+      content,
+      ts6.ScriptTarget.Latest,
+      true,
+      ts6.ScriptKind.TS
+    );
+    const decoratorToMessageType = this.buildDecoratorToMessageTypeMap(decoratorNames);
+    const context = {
+      sourceFile,
+      content,
+      messageTypes,
+      decoratorToMessageType
+    };
+    const { targetClassNames, targetClasses } = this.findTargetClasses(context);
+    if (targetClasses.length === 0) {
+      return { content, usedModuleSpecifiers: /* @__PURE__ */ new Set() };
+    }
+    const relatedTypeNames = this.computeRelatedTypeNames(targetClassNames);
+    const usedIdentifiers = this.collectUsedIdentifiers(targetClasses);
+    const localTypeDeclarations = this.collectLocalTypeDeclarations(sourceFile);
+    const includedLocalTypes = this.resolveIncludedLocalTypes(
+      usedIdentifiers,
+      relatedTypeNames,
+      localTypeDeclarations
+    );
+    const extractedSymbols = {
+      targetClassNames,
+      targetClasses,
+      usedIdentifiers,
+      includedLocalTypes,
+      localTypeDeclarations
+    };
+    return this.generateExtractedOutput(context, extractedSymbols);
+  }
+  buildDecoratorToMessageTypeMap(decoratorNames) {
+    const names = { ...DEFAULT_DECORATOR_NAMES, ...decoratorNames };
+    return {
+      [names.event]: "event",
+      [names.command]: "command",
+      [names.query]: "query"
+    };
+  }
+  findTargetClasses(context) {
+    const targetClassNames = /* @__PURE__ */ new Set();
+    const targetClasses = [];
+    const findClasses = (node) => {
+      if (ts6.isClassDeclaration(node) && node.name) {
+        for (const [decoratorName, messageType] of Object.entries(
+          context.decoratorToMessageType
+        )) {
+          if (hasDecorator(node, decoratorName) && context.messageTypes.includes(messageType)) {
+            targetClassNames.add(node.name.text);
+            targetClasses.push(node);
+            break;
+          }
+        }
+      }
+      ts6.forEachChild(node, findClasses);
+    };
+    findClasses(context.sourceFile);
+    return { targetClassNames, targetClasses };
+  }
+  computeRelatedTypeNames(targetClassNames) {
+    const relatedTypeNames = /* @__PURE__ */ new Set();
+    for (const className of targetClassNames) {
+      if (className.endsWith(REQUEST_SUFFIX)) {
+        const baseName = className.slice(0, -REQUEST_SUFFIX.length);
+        relatedTypeNames.add(baseName + "Response");
+        relatedTypeNames.add(baseName + "Payload");
+      } else if (className.endsWith(QUERY_SUFFIX)) {
+        const baseName = className.slice(0, -QUERY_SUFFIX.length);
+        relatedTypeNames.add(baseName + "QueryResult");
+        relatedTypeNames.add(baseName + "Payload");
+      }
+      relatedTypeNames.add(className + "Response");
+      relatedTypeNames.add(className + "Payload");
+    }
+    return relatedTypeNames;
+  }
+  collectUsedIdentifiers(targetClasses) {
+    const usedIdentifiers = /* @__PURE__ */ new Set();
+    const collectIdentifiers = (node) => {
+      if (ts6.isTypeReferenceNode(node) && ts6.isIdentifier(node.typeName)) {
+        usedIdentifiers.add(node.typeName.text);
+      }
+      if (ts6.isExpressionWithTypeArguments(node) && ts6.isIdentifier(node.expression)) {
+        usedIdentifiers.add(node.expression.text);
+      }
+      if (ts6.isIdentifier(node) && node.parent) {
+        const isHeritageOrTypeRef = ts6.isHeritageClause(node.parent.parent) || ts6.isTypeReferenceNode(node.parent);
+        if (isHeritageOrTypeRef) {
+          usedIdentifiers.add(node.text);
+        }
+      }
+      if (ts6.isDecorator(node)) {
+        this.collectDecoratorIdentifier(node, usedIdentifiers);
+      }
+      if (ts6.isCallExpression(node) && ts6.isIdentifier(node.expression)) {
+        usedIdentifiers.add(node.expression.text);
+      }
+      ts6.forEachChild(node, collectIdentifiers);
+    };
+    for (const cls of targetClasses) {
+      collectIdentifiers(cls);
+    }
+    return usedIdentifiers;
+  }
+  collectDecoratorIdentifier(decorator, usedIdentifiers) {
+    const expr = decorator.expression;
+    if (ts6.isIdentifier(expr)) {
+      usedIdentifiers.add(expr.text);
+    } else if (ts6.isCallExpression(expr) && ts6.isIdentifier(expr.expression)) {
+      usedIdentifiers.add(expr.expression.text);
+    }
+  }
+  collectLocalTypeDeclarations(sourceFile) {
+    const localTypeDeclarations = /* @__PURE__ */ new Map();
+    const collectLocalTypes = (node) => {
+      if (ts6.isInterfaceDeclaration(node) && node.name) {
+        this.addToDeclarationMap(
+          localTypeDeclarations,
+          node.name.text,
+          node
+        );
+      }
+      if (ts6.isTypeAliasDeclaration(node) && node.name) {
+        this.addToDeclarationMap(
+          localTypeDeclarations,
+          node.name.text,
+          node
+        );
+      }
+      if (ts6.isVariableStatement(node)) {
+        for (const decl of node.declarationList.declarations) {
+          if (ts6.isIdentifier(decl.name)) {
+            this.addToDeclarationMap(
+              localTypeDeclarations,
+              decl.name.text,
+              node
+            );
+          }
+        }
+      }
+      ts6.forEachChild(node, collectLocalTypes);
+    };
+    collectLocalTypes(sourceFile);
+    return localTypeDeclarations;
+  }
+  addToDeclarationMap(map, name, node) {
+    const existing = map.get(name) ?? [];
+    existing.push(node);
+    map.set(name, existing);
+  }
+  resolveIncludedLocalTypes(usedIdentifiers, relatedTypeNames, localTypeDeclarations) {
+    const includedLocalTypes = /* @__PURE__ */ new Set();
+    const queue = [...usedIdentifiers, ...relatedTypeNames];
+    while (queue.length > 0) {
+      const identifier = queue.shift();
+      if (includedLocalTypes.has(identifier)) continue;
+      const typeNodes = localTypeDeclarations.get(identifier);
+      if (!typeNodes || typeNodes.length === 0) continue;
+      includedLocalTypes.add(identifier);
+      const typeIdentifiers = this.collectTypeIdentifiersFromNodes(typeNodes);
+      for (const id of typeIdentifiers) {
+        if (!includedLocalTypes.has(id)) {
+          queue.push(id);
+          usedIdentifiers.add(id);
+        }
+      }
+    }
+    return includedLocalTypes;
+  }
+  collectTypeIdentifiersFromNodes(nodes) {
+    const typeIdentifiers = /* @__PURE__ */ new Set();
+    const collectFromType = (node) => {
+      if (ts6.isTypeReferenceNode(node) && ts6.isIdentifier(node.typeName)) {
+        typeIdentifiers.add(node.typeName.text);
+      }
+      if (ts6.isExpressionWithTypeArguments(node) && ts6.isIdentifier(node.expression)) {
+        typeIdentifiers.add(node.expression.text);
+      }
+      if (ts6.isComputedPropertyName(node)) {
+        this.collectComputedPropertyIdentifier(node, typeIdentifiers);
+      }
+      ts6.forEachChild(node, collectFromType);
+    };
+    for (const typeNode of nodes) {
+      collectFromType(typeNode);
+    }
+    return typeIdentifiers;
+  }
+  collectComputedPropertyIdentifier(node, typeIdentifiers) {
+    const expr = node.expression;
+    if (ts6.isPropertyAccessExpression(expr) && ts6.isIdentifier(expr.expression)) {
+      typeIdentifiers.add(expr.expression.text);
+    }
+    if (ts6.isIdentifier(expr)) {
+      typeIdentifiers.add(expr.text);
+    }
+  }
+  generateExtractedOutput(context, symbols) {
+    const output = [];
+    const importMap = this.buildImportMap(context.sourceFile);
+    const filteredImports = this.filterImports(
+      symbols.usedIdentifiers,
+      importMap,
+      symbols.includedLocalTypes
+    );
+    this.appendImportStatements(output, filteredImports);
+    this.appendLocalTypeDeclarations(output, context, symbols);
+    this.appendTargetClasses(output, context, symbols.targetClasses);
+    const usedModuleSpecifiers = new Set(filteredImports.keys());
+    return {
+      content: output.join("\n"),
+      usedModuleSpecifiers
+    };
+  }
+  buildImportMap(sourceFile) {
+    const importMap = /* @__PURE__ */ new Map();
+    const collectImports = (node) => {
+      if (ts6.isImportDeclaration(node)) {
+        const moduleSpecifier = node.moduleSpecifier.text;
+        const namedBindings = node.importClause?.namedBindings;
+        const isTypeOnly = node.importClause?.isTypeOnly ?? false;
+        if (namedBindings && ts6.isNamedImports(namedBindings)) {
+          for (const element of namedBindings.elements) {
+            importMap.set(element.name.text, {
+              moduleSpecifier,
+              isTypeOnly
+            });
+          }
+        }
+      }
+      ts6.forEachChild(node, collectImports);
+    };
+    collectImports(sourceFile);
+    return importMap;
+  }
+  filterImports(usedIdentifiers, importMap, includedLocalTypes) {
+    const filteredImports = /* @__PURE__ */ new Map();
+    for (const identifier of usedIdentifiers) {
+      const importInfo = importMap.get(identifier);
+      if (!importInfo || includedLocalTypes.has(identifier)) {
+        continue;
+      }
+      const existing = filteredImports.get(importInfo.moduleSpecifier);
+      if (existing) {
+        existing.identifiers.add(identifier);
+      } else {
+        filteredImports.set(importInfo.moduleSpecifier, {
+          identifiers: /* @__PURE__ */ new Set([identifier]),
+          isTypeOnly: importInfo.isTypeOnly
+        });
+      }
+    }
+    return filteredImports;
+  }
+  appendImportStatements(output, filteredImports) {
+    for (const [moduleSpecifier, info] of filteredImports) {
+      const identifiers = [...info.identifiers].sort().join(", ");
+      const typeOnlyPrefix = info.isTypeOnly ? "type " : "";
+      output.push(
+        `import ${typeOnlyPrefix}{ ${identifiers} } from "${moduleSpecifier}";`
+      );
+    }
+    if (output.length > 0) {
+      output.push("");
+    }
+  }
+  appendLocalTypeDeclarations(output, context, symbols) {
+    const outputNodes = /* @__PURE__ */ new Set();
+    for (const typeName of symbols.includedLocalTypes) {
+      const typeNodes = symbols.localTypeDeclarations.get(typeName);
+      if (!typeNodes) continue;
+      for (const typeNode of typeNodes) {
+        if (outputNodes.has(typeNode)) continue;
+        outputNodes.add(typeNode);
+        this.appendNodeWithExport(output, context, typeNode);
+      }
+    }
+  }
+  appendTargetClasses(output, context, targetClasses) {
+    for (const cls of targetClasses) {
+      this.appendNodeWithExport(output, context, cls);
+    }
+  }
+  appendNodeWithExport(output, context, node) {
+    const nodeText = context.content.substring(node.getStart(context.sourceFile), node.end).trim();
+    const hasExport = this.nodeHasExportKeyword(node);
+    if (hasExport) {
+      output.push(nodeText);
+    } else {
+      output.push("export " + nodeText);
+    }
+    output.push("");
+  }
+  nodeHasExportKeyword(node) {
+    const isExportableDeclaration = ts6.isInterfaceDeclaration(node) || ts6.isTypeAliasDeclaration(node) || ts6.isVariableStatement(node) || ts6.isClassDeclaration(node);
+    if (!isExportableDeclaration) {
+      return false;
+    }
+    const declarationNode = node;
+    return declarationNode.modifiers?.some(
+      (m) => m.kind === ts6.SyntaxKind.ExportKeyword
+    ) ?? false;
+  }
+};
+var TYPESCRIPT_EXTENSIONS2 = [".ts", ".tsx", ".d.ts"];
+var INDEX_FILE2 = "index.ts";
+var Tsconfig = class _Tsconfig {
+  constructor(paths) {
+    this.paths = paths;
+  }
+  static NONE = new _Tsconfig(/* @__PURE__ */ new Map());
+  static async load(tsconfigPath, fs) {
+    const absolutePath = path3__default.resolve(tsconfigPath);
+    const configDir = path3__default.dirname(absolutePath);
+    const content = await fs.readFile(absolutePath);
+    const { config, error } = ts6__default.parseConfigFileTextToJson(absolutePath, content);
+    if (error) {
+      throw new Error(
+        `Failed to parse tsconfig: ${ts6__default.flattenDiagnosticMessageText(error.messageText, "\n")}`
+      );
+    }
+    const parsed = ts6__default.parseJsonConfigFileContent(config, ts6__default.sys, configDir);
+    const baseUrl = parsed.options.baseUrl ?? configDir;
+    const paths = /* @__PURE__ */ new Map();
+    if (parsed.options.paths) {
+      for (const [alias, targets] of Object.entries(parsed.options.paths)) {
+        const resolvedTargets = targets.map(
+          (target) => path3__default.join(baseUrl, target)
+        );
+        paths.set(alias, resolvedTargets);
+      }
+    }
+    return new _Tsconfig(paths);
+  }
+  /**
+   * Pure string transformation: resolves path alias to potential file paths.
+   * Returns null if no alias matches.
+   */
+  resolvePath(importPath) {
+    for (const [pattern, targets] of this.paths) {
+      const wildcardMatch = this.matchPathPattern(importPath, pattern);
+      if (wildcardMatch === null) {
+        continue;
+      }
+      return targets.map((target) => target.replace("*", wildcardMatch));
+    }
+    return null;
+  }
+  matchPathPattern(moduleSpecifier, pattern) {
+    if (pattern.endsWith("*")) {
+      const prefix = pattern.slice(0, -1);
+      if (moduleSpecifier.startsWith(prefix)) {
+        return moduleSpecifier.slice(prefix.length);
+      }
+    } else if (moduleSpecifier === pattern) {
+      return "";
+    }
+    return null;
+  }
+};
+var ContextConfig = class _ContextConfig {
+  fs;
+  tsconfig;
+  name;
+  sourceDir;
+  responseNamingConventions;
+  constructor(name, sourceDir, tsconfig, fs, responseNamingConventions) {
+    this.name = name;
+    this.sourceDir = sourceDir;
+    this.tsconfig = tsconfig;
+    this.fs = fs;
+    this.responseNamingConventions = responseNamingConventions;
+  }
+  /**
+   * Factory method to create ContextConfig with properly loaded tsconfig.
+   */
+  static async create(input, configDir, fs = nodeFileSystem) {
+    if (!input.name) {
+      throw new Error("ContextConfig requires 'name'");
+    }
+    if (!input.path) {
+      throw new Error(`ContextConfig '${input.name}' requires 'path'`);
+    }
+    const basePath = path3__default.resolve(configDir, input.path);
+    const sourceDir = path3__default.resolve(basePath, input.sourceDir ?? "src");
+    const tsconfig = await this.loadTsconfig(basePath, input.tsconfigPath, fs);
+    return new _ContextConfig(
+      input.name,
+      sourceDir,
+      tsconfig,
+      fs,
+      input.responseNamingConventions
+    );
+  }
+  static async loadTsconfig(basePath, inputPath, fs) {
+    const tsconfigPath = path3__default.resolve(basePath, inputPath ?? "tsconfig.json");
+    if (!await fs.exists(tsconfigPath)) {
+      return Tsconfig.NONE;
+    }
+    return Tsconfig.load(tsconfigPath, fs);
+  }
+  /**
+   * Creates a ContextConfig without async loading (for cases where tsconfig is not needed
+   * or already handled externally).
+   */
+  static createSync(name, sourceDir, fs = nodeFileSystem, responseNamingConventions) {
+    return new _ContextConfig(
+      name,
+      sourceDir,
+      Tsconfig.NONE,
+      fs,
+      responseNamingConventions
+    );
+  }
+  /**
+   * Resolves a module specifier (path alias) to actual file path.
+   * Only handles non-relative imports (path aliases).
+   *
+   * @param moduleSpecifier - The import path to resolve (e.g., "@/utils/helper")
+   * @returns Object with resolvedPath (null if external) and isExternal flag
+   */
+  async resolvePath(moduleSpecifier) {
+    const resolvedPaths = this.tsconfig.resolvePath(moduleSpecifier);
+    if (!resolvedPaths) {
+      return { resolvedPath: null, isExternal: true };
+    }
+    for (const resolvedPath of resolvedPaths) {
+      const filePath = await this.tryResolveWithExtensions(resolvedPath);
+      if (filePath && filePath.startsWith(this.sourceDir)) {
+        return { resolvedPath: filePath, isExternal: false };
+      }
+    }
+    return { resolvedPath: null, isExternal: true };
+  }
+  async tryResolveWithExtensions(basePath) {
+    const extensionCandidates = TYPESCRIPT_EXTENSIONS2.map((ext) => basePath + ext);
+    const indexCandidate = path3__default.join(basePath, INDEX_FILE2);
+    const candidates = [...extensionCandidates, indexCandidate];
+    for (const candidate of candidates) {
+      if (await this.fs.exists(candidate)) {
+        return candidate;
+      }
+    }
+    return null;
+  }
+};
+
+// src/config-loader.ts
+var SUPPORTED_GLOB_PARTS_COUNT = 2;
+var ConfigLoader = class {
+  fs;
+  constructor(options = {}) {
+    this.fs = options.fileSystem ?? nodeFileSystem;
+  }
+  async load(configPath) {
+    const absolutePath = resolve(configPath);
+    const config = await this.loadTypeScriptConfig(absolutePath);
+    return this.extractContractsConfig(config, dirname(absolutePath));
+  }
+  async loadTypeScriptConfig(absolutePath) {
+    const source = await this.fs.readFile(absolutePath);
+    const result = ts6__default.transpileModule(source, {
+      compilerOptions: {
+        module: ts6__default.ModuleKind.CommonJS,
+        target: ts6__default.ScriptTarget.ES2020,
+        esModuleInterop: true
+      }
+    });
+    const exports$1 = {};
+    const moduleWrapper = new Function("exports", result.outputText);
+    moduleWrapper(exports$1);
+    return exports$1.default ?? exports$1;
+  }
+  async extractContractsConfig(config, configDir) {
+    const contracts = config.contracts;
+    if (!contracts) {
+      throw new ConfigLoadError("Missing 'contracts' section in config");
+    }
+    if (!contracts.contexts || !Array.isArray(contracts.contexts)) {
+      throw new ConfigLoadError("Missing 'contracts.contexts' in config");
+    }
+    const contexts = await this.resolveContexts(contracts.contexts, configDir);
+    if (contexts.length === 0) {
+      throw new ConfigLoadError("No contexts found from 'contexts'");
+    }
+    const decoratorNames = mergeDecoratorNames(contracts.decoratorNames);
+    return {
+      contexts,
+      pathAliasRewrites: contracts.pathAliasRewrites,
+      externalDependencies: contracts.externalDependencies,
+      decoratorNames,
+      responseNamingConventions: contracts.responseNamingConventions,
+      removeDecorators: contracts.removeDecorators ?? true
+    };
+  }
+  async resolveContexts(contextsConfig, configDir) {
+    const contexts = [];
+    for (let i = 0; i < contextsConfig.length; i++) {
+      const item = contextsConfig[i];
+      if (typeof item === "string") {
+        const resolvedContexts = await this.resolveStringContext(item, configDir);
+        contexts.push(...resolvedContexts);
+      } else {
+        const contextConfig = await this.createObjectContext(item, i, configDir);
+        contexts.push(contextConfig);
+      }
+    }
+    return contexts;
+  }
+  async resolveStringContext(contextPath, configDir) {
+    if (contextPath.includes("*")) {
+      return this.expandGlobPattern(contextPath, configDir);
+    }
+    const basePath = resolve(configDir, contextPath);
+    const name = basename(basePath);
+    return [await ContextConfig.create(
+      { name, path: contextPath },
+      configDir,
+      this.fs
+    )];
+  }
+  async expandGlobPattern(pattern, configDir) {
+    const packageDirs = await this.matchGlobPattern(pattern, configDir);
+    return Promise.all(
+      packageDirs.map((dir) => {
+        const name = basename(dir);
+        const relativePath = relative(configDir, dir);
+        return ContextConfig.create(
+          { name, path: relativePath },
+          configDir,
+          this.fs
+        );
+      })
+    );
+  }
+  async createObjectContext(ctx, index, configDir) {
+    if (!ctx.name || typeof ctx.name !== "string") {
+      throw new ConfigLoadError(
+        `Invalid context at index ${index}: missing 'name'`
+      );
+    }
+    if (!ctx.path || typeof ctx.path !== "string") {
+      throw new ConfigLoadError(
+        `Invalid context at index ${index}: missing 'path'`
+      );
+    }
+    return ContextConfig.create(ctx, configDir, this.fs);
+  }
+  async matchGlobPattern(pattern, configDir) {
+    const globParts = pattern.split("*");
+    if (globParts.length !== SUPPORTED_GLOB_PARTS_COUNT) {
+      throw new ConfigLoadError(
+        `Invalid glob pattern: "${pattern}". Only single wildcard patterns like "packages/*" are supported.`
+      );
+    }
+    const [prefix, suffix] = globParts;
+    const baseDir = resolve(configDir, prefix);
+    if (!await this.fs.exists(baseDir)) {
+      return [];
+    }
+    const entries = await this.fs.readdir(baseDir);
+    const matchedDirs = [];
+    for (const entry of entries) {
+      const fullPath = resolve(baseDir, entry);
+      const stats = await this.fs.stat(fullPath);
+      if (!stats.isDirectory()) {
+        continue;
+      }
+      if (suffix) {
+        const suffixPath = resolve(fullPath, suffix.replace(/^\//, ""));
+        if (await this.fs.exists(suffixPath)) {
+          matchedDirs.push(fullPath);
+        }
+      } else {
+        matchedDirs.push(fullPath);
+      }
+    }
+    return matchedDirs.sort();
+  }
+};
+
+// src/registry-generator.ts
+var DEFAULT_OPTIONS = {
+  messageRegistryImport: "@hexaijs/plugin-contracts-generator/runtime"
+};
+function hasMessages(ctx) {
+  return ctx.events.length > 0 || ctx.commands.length > 0 || (ctx.queries?.length ?? 0) > 0;
+}
+function getAllMessages(ctx) {
+  return [...ctx.events, ...ctx.commands, ...ctx.queries ?? []];
+}
+var RegistryGenerator = class {
+  options;
+  constructor(options = {}) {
+    this.options = { ...DEFAULT_OPTIONS, ...options };
+  }
+  generate(contexts) {
+    const allMessages = contexts.flatMap(
+      (ctx) => getAllMessages(ctx).map((message) => ({
+        message,
+        contextName: ctx.contextName
+      }))
+    );
+    if (allMessages.length === 0) {
+      return this.generateEmptyRegistry();
+    }
+    if (this.options.useNamespace) {
+      return this.generateWithNamespace(contexts, allMessages);
+    }
+    const imports = this.generateImports(contexts);
+    const registrations = this.generateRegistrations(allMessages);
+    return [
+      imports,
+      "",
+      "export const messageRegistry = new MessageRegistry()",
+      registrations
+    ].join("\n");
+  }
+  generateEmptyRegistry() {
+    return [
+      `import { MessageRegistry } from "${this.options.messageRegistryImport}";`,
+      "",
+      "export const messageRegistry = new MessageRegistry();",
+      ""
+    ].join("\n");
+  }
+  generateWithNamespace(contexts, allMessages) {
+    const imports = this.generateNamespaceImports(contexts);
+    const exports$1 = this.generateNamespaceExports(contexts);
+    const registrations = this.generateNamespaceRegistrations(allMessages);
+    return [
+      imports,
+      "",
+      exports$1,
+      "",
+      "export const messageRegistry = new MessageRegistry()",
+      registrations
+    ].join("\n");
+  }
+  getNamespaceInfos(contexts) {
+    return contexts.filter(hasMessages).map((ctx) => ({
+      importPath: ctx.importPath ?? `./${ctx.contextName}`,
+      namespace: this.toNamespace(ctx.contextName)
+    }));
+  }
+  generateNamespaceImports(contexts) {
+    return [
+      `import { MessageRegistry } from "${this.options.messageRegistryImport}";`,
+      ...this.getNamespaceInfos(contexts).map(
+        ({ importPath, namespace }) => `import * as ${namespace} from "${importPath}";`
+      )
+    ].join("\n");
+  }
+  generateNamespaceExports(contexts) {
+    return this.getNamespaceInfos(contexts).map(
+      ({ importPath, namespace }) => `export * as ${namespace} from "${importPath}";`
+    ).join("\n");
+  }
+  generateNamespaceRegistrations(messages) {
+    const lines = messages.map(({ message, contextName }) => {
+      const namespace = this.toNamespace(contextName);
+      return `    .register(${namespace}.${message.name})`;
+    });
+    return lines.join("\n") + ";\n";
+  }
+  toNamespace(contextName) {
+    return contextName.replace(
+      /-([a-z])/g,
+      (_, letter) => letter.toUpperCase()
+    );
+  }
+  generateImports(contexts) {
+    const lines = [
+      `import { MessageRegistry } from "${this.options.messageRegistryImport}";`
+    ];
+    for (const ctx of contexts) {
+      const messageNames = getAllMessages(ctx).map((m) => m.name);
+      if (messageNames.length > 0) {
+        const importPath = ctx.importPath ?? `./${ctx.contextName}`;
+        lines.push(
+          `import { ${messageNames.join(", ")} } from "${importPath}";`
+        );
+      }
+    }
+    return lines.join("\n");
+  }
+  generateRegistrations(messages) {
+    const lines = messages.map(
+      ({ message }) => `    .register(${message.name})`
+    );
+    return lines.join("\n") + ";\n";
+  }
+};
+var ReexportGenerator = class {
+  fs;
+  constructor(options = {}) {
+    this.fs = options.fileSystem ?? nodeFileSystem;
+  }
+  /**
+   * Analyzes files to find imports that match pathAliasRewrites
+   * and groups them by rewritten path
+   */
+  async analyze(options) {
+    const { files, pathAliasRewrites } = options;
+    const rewrittenToOriginal = /* @__PURE__ */ new Map();
+    for (const [original, rewritten] of pathAliasRewrites) {
+      rewrittenToOriginal.set(rewritten, original);
+    }
+    const allImports = [];
+    for (const file of files) {
+      const content = await this.fs.readFile(file);
+      const imports = this.extractRewrittenImports(content, rewrittenToOriginal);
+      allImports.push(...imports);
+    }
+    return this.groupImportsByPath(allImports);
+  }
+  /**
+   * Generates re-export files
+   */
+  async generate(options) {
+    const { outputDir, reexportFiles } = options;
+    const generatedFiles = [];
+    for (const reexport of reexportFiles) {
+      const filePath = path3.join(outputDir, reexport.relativePath);
+      const content = this.generateReexportContent(reexport);
+      await this.fs.mkdir(path3.dirname(filePath), { recursive: true });
+      await this.fs.writeFile(filePath, content);
+      generatedFiles.push(filePath);
+    }
+    return generatedFiles;
+  }
+  /**
+   * Extracts imports from source content that match rewritten prefixes
+   */
+  extractRewrittenImports(content, rewrittenToOriginal) {
+    const sourceFile = ts6.createSourceFile(
+      "temp.ts",
+      content,
+      ts6.ScriptTarget.Latest,
+      true
+    );
+    const imports = [];
+    ts6.forEachChild(sourceFile, (node) => {
+      if (!ts6.isImportDeclaration(node) || !node.importClause) {
+        return;
+      }
+      const moduleSpecifier = node.moduleSpecifier.text;
+      for (const [rewrittenPrefix, originalPrefix] of rewrittenToOriginal) {
+        if (moduleSpecifier.startsWith(rewrittenPrefix)) {
+          const symbols = this.extractSymbolNames(node.importClause);
+          if (symbols.length > 0) {
+            const suffix = moduleSpecifier.slice(rewrittenPrefix.length);
+            const originalPath = originalPrefix + suffix;
+            imports.push({
+              rewrittenPath: moduleSpecifier,
+              originalPath,
+              symbols,
+              isTypeOnly: node.importClause.isTypeOnly ?? false
+            });
+          }
+          break;
+        }
+      }
+    });
+    return imports;
+  }
+  /**
+   * Extracts symbol names from import clause
+   */
+  extractSymbolNames(importClause) {
+    const names = [];
+    if (importClause.name) {
+      names.push(importClause.name.text);
+    }
+    if (importClause.namedBindings && ts6.isNamedImports(importClause.namedBindings)) {
+      for (const element of importClause.namedBindings.elements) {
+        const originalName = element.propertyName?.text ?? element.name.text;
+        names.push(originalName);
+      }
+    }
+    return names;
+  }
+  /**
+   * Groups imports by rewritten path and merges symbols
+   */
+  groupImportsByPath(imports) {
+    const grouped = /* @__PURE__ */ new Map();
+    for (const imp of imports) {
+      const existing = grouped.get(imp.rewrittenPath);
+      if (existing) {
+        for (const symbol of imp.symbols) {
+          existing.symbols.add(symbol);
+        }
+        if (!imp.isTypeOnly) {
+          existing.hasValueImport = true;
+        }
+      } else {
+        grouped.set(imp.rewrittenPath, {
+          originalPath: imp.originalPath,
+          symbols: new Set(imp.symbols),
+          hasValueImport: !imp.isTypeOnly
+        });
+      }
+    }
+    const result = [];
+    for (const [rewrittenPath, data] of grouped) {
+      const relativePath = this.rewrittenPathToRelativePath(rewrittenPath);
+      result.push({
+        relativePath,
+        originalModule: data.originalPath,
+        symbols: Array.from(data.symbols).sort(),
+        isTypeOnly: !data.hasValueImport
+      });
+    }
+    return result.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+  }
+  /**
+   * Converts a rewritten package path to a relative file path
+   * e.g., "@libera/contracts/common/request" with prefix "@libera/contracts"
+   *       -> "common/request.ts"
+   */
+  rewrittenPathToRelativePath(rewrittenPath) {
+    const parts = rewrittenPath.split("/");
+    let subpathStart;
+    if (parts[0].startsWith("@")) {
+      subpathStart = 2;
+    } else {
+      subpathStart = 1;
+    }
+    const subpath = parts.slice(subpathStart).join("/");
+    if (!subpath) {
+      return "index.ts";
+    }
+    return subpath + ".ts";
+  }
+  /**
+   * Generates the content for a re-export file
+   */
+  generateReexportContent(reexport) {
+    const exportKeyword = reexport.isTypeOnly ? "export type" : "export";
+    const symbols = reexport.symbols.join(", ");
+    return `${exportKeyword} { ${symbols} } from "${reexport.originalModule}";
+`;
+  }
+};
+
+// src/logger.ts
+var LOG_LEVEL_PRIORITY = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var ConsoleLogger = class {
+  level;
+  constructor(options = {}) {
+    this.level = options.level ?? "info";
+  }
+  debug(message) {
+    if (this.shouldLog("debug")) {
+      console.debug(message);
+    }
+  }
+  info(message) {
+    if (this.shouldLog("info")) {
+      console.info(message);
+    }
+  }
+  warn(message) {
+    if (this.shouldLog("warn")) {
+      console.warn(message);
+    }
+  }
+  error(message) {
+    if (this.shouldLog("error")) {
+      console.error(message);
+    }
+  }
+  shouldLog(level) {
+    return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[this.level];
+  }
+};
+var NoopLogger = class {
+  debug() {
+  }
+  info() {
+  }
+  warn() {
+  }
+  error() {
+  }
+};
+var noopLogger = new NoopLogger();
+var DEFAULT_EXCLUDE_DEPENDENCIES = [
+  "**/*.test.ts",
+  "**/*.spec.ts",
+  "**/*.eh.ts",
+  "**/db.ts",
+  "**/infra/**"
+];
+var ContractsPipeline = class _ContractsPipeline {
+  constructor(deps, messageTypes) {
+    this.deps = deps;
+    this.messageTypes = messageTypes;
+  }
+  messageTypes;
+  static create(options) {
+    const fileSystem = options.fileSystem ?? nodeFileSystem;
+    const logger = options.logger ?? noopLogger;
+    const excludeDependencies = options.excludeDependencies ?? DEFAULT_EXCLUDE_DEPENDENCIES;
+    const scanner = new Scanner({ fileSystem, messageTypes: options.messageTypes });
+    const parser = new Parser({
+      responseNamingConventions: options.responseNamingConventions ?? options.contextConfig.responseNamingConventions,
+      messageTypes: options.messageTypes
+    });
+    const fileGraphResolver = FileGraphResolver.create({
+      contextConfig: options.contextConfig,
+      fileSystem,
+      excludeDependencies
+    });
+    const fileCopier = new FileCopier({ fileSystem });
+    return new _ContractsPipeline(
+      {
+        scanner,
+        parser,
+        fileGraphResolver,
+        fileCopier,
         fileSystem,
-        logger,
+        logger
+      },
+      options.messageTypes
+    );
+  }
+  static fromDependencies(deps) {
+    return new _ContractsPipeline(deps);
+  }
+  async execute(options) {
+    const { contextName, sourceDir, outputDir, pathAliasRewrites, removeDecorators } = options;
+    const contextOutputDir = join(outputDir, contextName);
+    this.deps.logger.info(`Processing context: ${contextName}`);
+    this.deps.logger.debug(`  Source: ${sourceDir}`);
+    this.deps.logger.debug(`  Output: ${contextOutputDir}`);
+    const decoratedFiles = await this.scan(sourceDir);
+    const messages = await this.parse(decoratedFiles, sourceDir);
+    const fileGraph = await this.resolve(decoratedFiles, sourceDir);
+    const responseTypesToExport = this.collectResponseTypesToExport(messages);
+    const copiedFiles = await this.copy(fileGraph, sourceDir, contextOutputDir, pathAliasRewrites, responseTypesToExport, removeDecorators, this.messageTypes);
+    await this.exportBarrel(copiedFiles, contextOutputDir);
+    this.deps.logger.info(`Completed context: ${contextName} (${messages.events.length} events, ${messages.commands.length} commands, ${messages.queries.length} queries, ${copiedFiles.length} files)`);
+    return {
+      events: messages.events,
+      commands: messages.commands,
+      queries: messages.queries,
+      copiedFiles
+    };
+  }
+  collectResponseTypesToExport(messages) {
+    const result = /* @__PURE__ */ new Map();
+    const allMessages = [...messages.commands, ...messages.queries];
+    for (const message of allMessages) {
+      if (message.resultType?.kind !== "reference") continue;
+      const typeName = message.resultType.name;
+      const sourceFile = message.sourceFile.absolutePath;
+      const typeDef = messages.typeDefinitions.find(
+        (t) => t.name === typeName && t.sourceFile.absolutePath === sourceFile && !t.exported
+      );
+      if (typeDef) {
+        const existing = result.get(sourceFile) ?? [];
+        if (!existing.includes(typeName)) {
+          existing.push(typeName);
+          result.set(sourceFile, existing);
+        }
+      }
+    }
+    if (result.size > 0) {
+      this.deps.logger.debug(`Found ${result.size} file(s) with unexported response types`);
+    }
+    return result;
+  }
+  async scan(sourceDir) {
+    this.deps.logger.debug(`Scanning for decorated files in ${sourceDir}`);
+    const files = await this.deps.scanner.scan(sourceDir);
+    this.deps.logger.debug(`Found ${files.length} decorated file(s)`);
+    return files;
+  }
+  async parse(files, sourceRoot) {
+    this.deps.logger.debug(`Parsing ${files.length} file(s)`);
+    const events = [];
+    const commands = [];
+    const queries = [];
+    const typeDefinitions = [];
+    for (const file of files) {
+      const content = await this.deps.fileSystem.readFile(file);
+      const sourceFileInfo = {
+        absolutePath: file,
+        relativePath: relative(sourceRoot, file)
+      };
+      const result = this.deps.parser.parse(content, sourceFileInfo);
+      events.push(...result.events);
+      commands.push(...result.commands);
+      queries.push(...result.queries);
+      typeDefinitions.push(...result.typeDefinitions);
+    }
+    this.deps.logger.debug(`Parsed ${events.length} event(s), ${commands.length} command(s), ${queries.length} query(s), ${typeDefinitions.length} type(s)`);
+    return { events, commands, queries, typeDefinitions };
+  }
+  async resolve(entryPoints, sourceRoot) {
+    this.deps.logger.debug(`Resolving dependencies for ${entryPoints.length} entry point(s)`);
+    const graph = await this.deps.fileGraphResolver.buildGraph(entryPoints, sourceRoot);
+    this.deps.logger.debug(`Resolved ${graph.nodes.size} file(s) in dependency graph`);
+    return graph;
+  }
+  async copy(fileGraph, sourceRoot, outputDir, pathAliasRewrites, responseTypesToExport, removeDecorators, messageTypes) {
+    this.deps.logger.debug(`Copying files to ${outputDir}`);
+    await this.deps.fileSystem.mkdir(outputDir, { recursive: true });
+    const result = await this.deps.fileCopier.copyFiles({
+      sourceRoot,
+      outputDir,
+      fileGraph,
+      pathAliasRewrites,
+      responseTypesToExport,
+      removeDecorators,
+      messageTypes
     });
-    return pipeline.execute({
-        contextName,
-        sourceDir,
-        outputDir,
-        pathAliasRewrites,
-        removeDecorators,
+    this.deps.logger.debug(`Copied ${result.copiedFiles.length} file(s)`);
+    return result.copiedFiles;
+  }
+  async exportBarrel(copiedFiles, outputDir) {
+    this.deps.logger.debug(`Generating barrel export at ${outputDir}/index.ts`);
+    const indexContent = this.deps.fileCopier.generateBarrelExport(copiedFiles, outputDir);
+    await this.deps.fileSystem.writeFile(join(outputDir, "index.ts"), indexContent);
+  }
+};
+var DEFAULT_CONFIG_PATH = "application.config.ts";
+var EXIT_CODE_ERROR = 1;
+var VALID_MESSAGE_TYPES = ["event", "command", "query"];
+var CLI_OPTIONS = {
+  config: { short: "-c", long: "--config"},
+  outputDir: { short: "-o", long: "--output-dir"},
+  messageTypes: { short: "-m", long: "--message-types"},
+  generateMessageRegistry: { short: null, long: "--generate-message-registry"},
+  help: { short: "-h", long: "--help"}
+};
+function parseMessageTypes(value) {
+  const types = value.split(",").map((type) => type.trim().toLowerCase());
+  const invalidTypes = types.filter((type) => !VALID_MESSAGE_TYPES.includes(type));
+  if (invalidTypes.length > 0) {
+    throw new Error(
+      `Invalid message type(s): ${invalidTypes.join(", ")}. Valid types are: ${VALID_MESSAGE_TYPES.join(", ")}`
+    );
+  }
+  return types;
+}
+function extractOptionValue(args, currentIndex, optionName) {
+  const currentArg = args[currentIndex];
+  const equalsIndex = currentArg.indexOf("=");
+  if (equalsIndex !== -1) {
+    return {
+      value: currentArg.slice(equalsIndex + 1),
+      nextIndex: currentIndex
+    };
+  }
+  const nextValue = args[currentIndex + 1];
+  if (!nextValue) {
+    throw new Error(`Missing value for ${optionName} option`);
+  }
+  return {
+    value: nextValue,
+    nextIndex: currentIndex + 1
+  };
+}
+function matchesOption(arg, option) {
+  const matchesShortOrLong = arg === option.short || arg === option.long;
+  const matchesLongWithValue = option.long !== null && arg.startsWith(`${option.long}=`);
+  return matchesShortOrLong || matchesLongWithValue;
+}
+function parseArgs(args) {
+  const options = {
+    config: DEFAULT_CONFIG_PATH
+  };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (matchesOption(arg, CLI_OPTIONS.config)) {
+      const { value, nextIndex } = extractOptionValue(args, i, "--config");
+      options.config = value;
+      i = nextIndex;
+    } else if (matchesOption(arg, CLI_OPTIONS.outputDir)) {
+      const { value, nextIndex } = extractOptionValue(args, i, "--output-dir");
+      options.outputDir = value;
+      i = nextIndex;
+    } else if (matchesOption(arg, CLI_OPTIONS.messageTypes)) {
+      const { value, nextIndex } = extractOptionValue(args, i, "--message-types");
+      options.messageTypes = parseMessageTypes(value);
+      i = nextIndex;
+    } else if (matchesOption(arg, CLI_OPTIONS.generateMessageRegistry)) {
+      options.generateMessageRegistry = true;
+    } else if (matchesOption(arg, CLI_OPTIONS.help)) {
+      printHelp();
+      process.exit(0);
+    }
+  }
+  if (!options.outputDir) {
+    throw new Error("Missing required option: --output-dir");
+  }
+  return options;
+}
+function printHelp() {
+  console.log(`
+contracts-generator - Extract domain events and commands from TypeScript source
+
+Usage:
+  contracts-generator --output-dir <path> [options]
+
+Required:
+  -o, --output-dir <path>       Output directory for generated contracts
+
+Options:
+  -c, --config <path>           Path to config file (default: ${DEFAULT_CONFIG_PATH})
+  -m, --message-types <types>   Filter message types to extract (comma-separated)
+                                Valid types: ${VALID_MESSAGE_TYPES.join(", ")}
+                                Default: all types
+  --generate-message-registry   Generate message registry index.ts file
+                                Default: not generated
+  -h, --help                    Show this help message
+
+Config file format:
+  export default {
+    contracts: {
+      contexts: [
+        {
+          name: "lecture",
+          sourceDir: "packages/lecture/src",
+        },
+      ],
+      pathAliasRewrites: {
+        "@/": "@libera/",
+      },
+    },
+  };
+
+Examples:
+  # Extract all message types
+  contracts-generator --output-dir packages/contracts/src
+
+  # Extract only commands and queries
+  contracts-generator -o packages/contracts/requests -m command,query
+
+  # Extract only events
+  contracts-generator -o packages/contracts/events --message-types event
+
+  # Generate with message registry (index.ts)
+  contracts-generator -o packages/contracts/src --generate-message-registry
+
+  # Use with custom config
+  contracts-generator -c app.config.ts -o packages/contracts/src
+`);
+}
+function calculateSummaryTotals(results) {
+  return results.reduce(
+    (totals, contextResult) => ({
+      events: totals.events + contextResult.result.events.length,
+      commands: totals.commands + contextResult.result.commands.length,
+      files: totals.files + contextResult.result.copiedFiles.length
+    }),
+    { events: 0, commands: 0, files: 0 }
+  );
+}
+function countTotalMessages(totals) {
+  return totals.events + totals.commands;
+}
+function logSummary(logger, totals) {
+  logger.info("\n--- Summary ---");
+  logger.info(`Total events: ${totals.events}`);
+  logger.info(`Total commands: ${totals.commands}`);
+  logger.info(`Total files copied: ${totals.files}`);
+}
+async function run(args) {
+  const options = parseArgs(args);
+  const configPath = resolve(options.config);
+  const configDir = dirname(configPath);
+  const outputDir = resolve(configDir, options.outputDir);
+  const logger = new ConsoleLogger({ level: "info" });
+  logger.info(`Loading config from: ${configPath}`);
+  const configLoader = new ConfigLoader();
+  const config = await configLoader.load(configPath);
+  logger.info(`Found ${config.contexts.length} context(s) to process`);
+  logger.info(`Output directory: ${outputDir}`);
+  if (options.messageTypes) {
+    logger.info(`Message types filter: ${options.messageTypes.join(", ")}`);
+  }
+  const pathAliasRewrites = config.pathAliasRewrites ? new Map(Object.entries(config.pathAliasRewrites)) : void 0;
+  const results = [];
+  for (const contextConfig of config.contexts) {
+    const pipeline = ContractsPipeline.create({
+      contextConfig,
+      messageTypes: options.messageTypes,
+      logger
+    });
+    const result = await pipeline.execute({
+      contextName: contextConfig.name,
+      sourceDir: contextConfig.sourceDir,
+      outputDir,
+      pathAliasRewrites,
+      removeDecorators: config.removeDecorators
+    });
+    results.push({ name: contextConfig.name, result, outputDir });
+  }
+  const totals = calculateSummaryTotals(results);
+  logSummary(logger, totals);
+  if (options.generateMessageRegistry) {
+    await generateRegistry(outputDir, results, totals, logger);
+  }
+  if (config.pathAliasRewrites) {
+    await generateReexports(config, outputDir, results, logger);
+  }
+}
+async function toContractsConfig(pluginConfig) {
+  const contexts = await Promise.all(
+    pluginConfig.contexts.map(
+      (ctx) => ContextConfig.create(
+        {
+          name: ctx.name,
+          path: ctx.path,
+          sourceDir: ctx.sourceDir,
+          tsconfigPath: ctx.tsconfigPath
+        },
+        process.cwd(),
+        nodeFileSystem
+      )
+    )
+  );
+  return {
+    contexts,
+    pathAliasRewrites: pluginConfig.pathAliasRewrites,
+    externalDependencies: pluginConfig.externalDependencies,
+    decoratorNames: mergeDecoratorNames(pluginConfig.decoratorNames),
+    responseNamingConventions: pluginConfig.responseNamingConventions,
+    removeDecorators: pluginConfig.removeDecorators ?? true
+  };
+}
+async function runWithConfig(options, pluginConfig) {
+  const outputDir = resolve(options.outputDir);
+  const logger = new ConsoleLogger({ level: "info" });
+  const config = await toContractsConfig(pluginConfig);
+  logger.info(`Found ${config.contexts.length} context(s) to process`);
+  logger.info(`Output directory: ${outputDir}`);
+  if (options.messageTypes) {
+    logger.info(`Message types filter: ${options.messageTypes.join(", ")}`);
+  }
+  const pathAliasRewrites = config.pathAliasRewrites ? new Map(Object.entries(config.pathAliasRewrites)) : void 0;
+  const results = [];
+  for (const contextConfig of config.contexts) {
+    const pipeline = ContractsPipeline.create({
+      contextConfig,
+      messageTypes: options.messageTypes,
+      logger
+    });
+    const result = await pipeline.execute({
+      contextName: contextConfig.name,
+      sourceDir: contextConfig.sourceDir,
+      outputDir,
+      pathAliasRewrites,
+      removeDecorators: config.removeDecorators
     });
+    results.push({ name: contextConfig.name, result, outputDir });
+  }
+  const totals = calculateSummaryTotals(results);
+  logSummary(logger, totals);
+  if (options.generateMessageRegistry) {
+    await generateRegistry(outputDir, results, totals, logger);
+  }
+  if (config.pathAliasRewrites) {
+    await generateReexports(config, outputDir, results, logger);
+  }
+}
+async function generateRegistry(outputDir, results, totals, logger) {
+  const contextMessages = results.map((contextResult) => {
+    const contextOutputDir = join(contextResult.outputDir, contextResult.name);
+    const importPath = "./" + relative(outputDir, contextOutputDir).replace(/\\/g, "/");
+    return {
+      contextName: contextResult.name,
+      events: contextResult.result.events,
+      commands: contextResult.result.commands,
+      queries: contextResult.result.queries,
+      importPath
+    };
+  });
+  const generator = new RegistryGenerator({ useNamespace: true });
+  const registryContent = generator.generate(contextMessages);
+  await nodeFileSystem.mkdir(outputDir, { recursive: true });
+  const indexPath = join(outputDir, "index.ts");
+  await nodeFileSystem.writeFile(indexPath, registryContent);
+  logger.info(`  Generated index.ts with ${countTotalMessages(totals)} message(s)`);
+}
+async function generateReexports(config, outputDir, results, logger) {
+  logger.info("\n--- Generating re-exports for pathAliasRewrites ---");
+  const pathAliasRewrites = new Map(Object.entries(config.pathAliasRewrites));
+  const allCopiedFiles = results.flatMap((contextResult) => contextResult.result.copiedFiles);
+  const generator = new ReexportGenerator({ fileSystem: nodeFileSystem });
+  const reexportFiles = await generator.analyze({
+    files: allCopiedFiles,
+    pathAliasRewrites
+  });
+  if (reexportFiles.length === 0) {
+    logger.info("  No re-export files needed");
+    return;
+  }
+  const generatedFiles = await generator.generate({
+    outputDir,
+    reexportFiles
+  });
+  logger.info(`  Generated ${generatedFiles.length} re-export file(s):`);
+  for (const file of generatedFiles) {
+    logger.info(`    - ${relative(outputDir, file)}`);
+  }
+}
+async function main() {
+  try {
+    await run(process.argv.slice(2));
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(`Error: ${error.message}`);
+    } else {
+      console.error("Unknown error occurred");
+    }
+    process.exit(EXIT_CODE_ERROR);
+  }
+}
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  main();
+}
+
+// src/hexai-plugin.ts
+var VALID_MESSAGE_TYPES2 = ["event", "command", "query"];
+function parseMessageTypes2(value) {
+  const types = value.split(",").map((type) => type.trim().toLowerCase());
+  const invalidTypes = types.filter(
+    (type) => !VALID_MESSAGE_TYPES2.includes(type)
+  );
+  if (invalidTypes.length > 0) {
+    throw new Error(
+      `Invalid message type(s): ${invalidTypes.join(", ")}. Valid types are: ${VALID_MESSAGE_TYPES2.join(", ")}`
+    );
+  }
+  return types;
+}
+var cliPlugin = {
+  name: "generate-contracts",
+  description: "Extract domain events, commands, and queries from bounded contexts",
+  options: [
+    {
+      flags: "-o, --output-dir <path>",
+      description: "Output directory for generated contracts",
+      required: true
+    },
+    {
+      flags: "-m, --message-types <types>",
+      description: "Filter message types (comma-separated: event,command,query)"
+    },
+    {
+      flags: "--generate-message-registry",
+      description: "Generate message registry index.ts file"
+    }
+  ],
+  run: async (args, config) => {
+    const options = {
+      outputDir: String(args.outputDir),
+      messageTypes: args.messageTypes ? parseMessageTypes2(String(args.messageTypes)) : void 0,
+      generateMessageRegistry: args.generateMessageRegistry === true
+    };
+    await runWithConfig(options, config);
+  }
+};
+
+// src/index.ts
+async function processContext(options) {
+  const {
+    contextName,
+    path: contextPath,
+    sourceDir,
+    outputDir,
+    pathAliasRewrites,
+    tsconfigPath,
+    responseNamingConventions,
+    removeDecorators,
+    messageTypes,
+    fileSystem = nodeFileSystem,
+    logger = noopLogger
+  } = options;
+  const contextConfig = await ContextConfig.create(
+    {
+      name: contextName,
+      path: contextPath,
+      sourceDir,
+      tsconfigPath,
+      responseNamingConventions
+    },
+    process.cwd(),
+    fileSystem
+  );
+  return ContractsPipeline.create({
+    contextConfig,
+    responseNamingConventions,
+    messageTypes,
+    fileSystem,
+    logger
+  }).execute({
+    contextName,
+    sourceDir: contextConfig.sourceDir,
+    outputDir,
+    pathAliasRewrites,
+    removeDecorators
+  });
 }
-// Hexai CLI plugin integration
-var hexai_plugin_1 = require("./hexai-plugin");
-Object.defineProperty(exports, "cliPlugin", { enumerable: true, get: function () { return hexai_plugin_1.cliPlugin; } });
+
+export { ConfigLoadError, ConfigLoader, ConfigurationError, ConsoleLogger, ContextConfig, ContractsPipeline, FileCopier, FileGraphResolver, FileNotFoundError, FileReadError, FileSystemError, FileWriteError, JsonParseError, MessageParserError, ModuleResolutionError, ParseError, Parser, PublicCommand, PublicEvent, PublicQuery, ReexportGenerator, RegistryGenerator, ResolutionError, Scanner, cliPlugin, isArrayType, isCommand, isDomainEvent, isFunctionType, isIntersectionType, isLiteralType, isObjectType, isPrimitiveType, isReferenceType, isTupleType, isUnionType, nodeFileSystem, noopLogger, processContext };
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map