@flink-app/flink 0.14.3 → 2.0.0-alpha.100

package/dist/src/TypeScriptCompiler.js

@@ -85,32 +85,80 @@ Object.defineProperty(exports, "__esModule", { value: true });
 var fs_1 = __importStar(require("fs"));
 var path_1 = require("path");
 var tiny_glob_1 = __importDefault(require("tiny-glob"));
-var ts_json_schema_generator_1 = require("ts-json-schema-generator");
 var ts_morph_1 = require("ts-morph");
+var FlinkLogFactory_1 = require("./FlinkLogFactory");
 var FsUtils_1 = require("./FsUtils");
-var TypeScriptUtils_1 = require("./TypeScriptUtils");
+var schema_extraction_1 = require("./schema-extraction");
 var utils_1 = require("./utils");
+var loadFlinkConfig_1 = require("./utils/loadFlinkConfig");
+var perfLog = FlinkLogFactory_1.FlinkLogFactory.createLogger("flink.perf");
+var initLog = FlinkLogFactory_1.FlinkLogFactory.createLogger("flink.init");
 var TypeScriptCompiler = /** @class */ (function () {
     function TypeScriptCompiler(cwd) {
-        this.cwd = cwd;
+        var _a, _b, _c, _d;
         /**
-         * Parsed typescript schemas that will be added to intermediate
-         * schemas.ts file.
-         *
-         * This will be written to file in a batch for performance reasons.
+         * Handler schemas collected during parseHandlers, to be generated later
          */
-        this.parsedTsSchemas = [];
+        this.handlerSchemasToGenerate = [];
         /**
-         * Imports needed for schemas.ts.
-         *
-         * This will be added to file in a batch for performance reasons.
+         * Tool schemas collected during parseTools, to be generated later
          */
-        this.tsSchemasSymbolsToImports = [];
+        this.toolSchemasToGenerate = [];
+        /**
+         * Pre-segmented source files by type (cached for performance)
+         */
+        this.handlerFiles = [];
+        this.repoFiles = [];
+        this.toolFiles = [];
+        this.agentFiles = [];
+        this.jobFiles = [];
+        this.serviceFiles = [];
+        /**
+         * Tool ID registry for agent validation (built during segmentation)
+         */
+        this.toolIdRegistry = new Set();
+        /**
+         * Compiler plugins loaded from flink.config.js
+         */
+        this.compilerPlugins = [];
+        this.disableServices = false;
+        /**
+         * Extension files collected during segmentation, keyed by generatedFile name
+         */
+        this.extensionFiles = new Map();
+        var path = require("path");
+        // Convert to absolute path to ensure consistent path comparisons
+        this.cwd = path.resolve(cwd);
         // Detect if project is using ESM based solely on package.json "type": "module"
-        this.isEsm = this.isEsmProject(cwd);
+        this.isEsm = this.isEsmProject(this.cwd);
+        var tsConfigPath = (0, path_1.join)(this.cwd, "tsconfig.json");
+        // Read and inherit important settings from tsconfig.json
+        var userTsConfig = {};
+        try {
+            if (fs_1.default.existsSync(tsConfigPath)) {
+                var tsConfigContent = fs_1.default.readFileSync(tsConfigPath, "utf8");
+                userTsConfig = JSON.parse(tsConfigContent);
+            }
+        }
+        catch (error) {
+            console.warn("Warning: Could not read tsconfig.json:", error);
+        }
         var compilerOptions = {
             noEmit: false, // We need to emit files
             outDir: (0, path_1.join)(cwd, "dist"),
+            // Inherit important performance options from user's tsconfig
+            skipLibCheck: (_b = (_a = userTsConfig.compilerOptions) === null || _a === void 0 ? void 0 : _a.skipLibCheck) !== null && _b !== void 0 ? _b : true, // Default to true for performance
+            // Performance optimizations for emit phase
+            // Since we already run getPreEmitDiagnostics() for type checking,
+            // we can use faster transpilation-only options
+            isolatedModules: true, // Transpile each file independently (much faster, no cross-file analysis)
+            // removeComments: true, // Smaller output, faster emit
+            importHelpers: false, // Don't import tslib helpers
+            // EXPERIMENTAL: Enable incremental compilation
+            // This creates a .tsbuildinfo file to cache type information
+            // Should speed up subsequent builds by avoiding full type checking
+            // incremental: true,
+            // tsBuildInfoFile: join(cwd, "dist", ".tsbuildinfo"),
         };
         // Set appropriate module settings based on detected module system
         if (this.isEsm) {
@@ -124,17 +172,351 @@ var TypeScriptCompiler = /** @class */ (function () {
             compilerOptions.module = ts_morph_1.ts.ModuleKind.CommonJS;
             compilerOptions.moduleResolution = ts_morph_1.ts.ModuleResolutionKind.NodeJs;
         }
-        var tsConfigPath = (0, path_1.join)(cwd, "tsconfig.json");
-        console.log("TypeScript config path:", require("path").resolve(tsConfigPath));
-        console.log("TypeScript version:", ts_morph_1.ts.version);
+        initLog.info("TypeScript version:", ts_morph_1.ts.version, "config path", require("path").resolve(tsConfigPath));
+        // console.log("Compiler options:", JSON.stringify(compilerOptions, null, 2));
+        var projectStartTime = Date.now();
         this.project = new ts_morph_1.Project({
             tsConfigFilePath: tsConfigPath,
             compilerOptions: compilerOptions,
+            skipAddingFilesFromTsConfig: true, // Don't auto-load all files - we'll add specific directories we need
+            skipFileDependencyResolution: true, // Don't resolve /// <reference> and type dependencies from node_modules
         });
+        var projectTime = Date.now() - projectStartTime;
+        perfLog.debug("\u2713 Project initialization completed in ".concat(projectTime, "ms"));
+        // Load Flink-specific source paths from tsconfig.json if available
+        var additionalSourcePaths = this.getFlinkSourcePaths(tsConfigPath);
+        // Load all TypeScript files from src/ directory
+        // This is simpler and faster than recursive import resolution
+        // We exclude test files and declarations to keep it lean
+        var defaultSourcePaths = [
+            (0, path_1.join)(cwd, "src/**/*.ts"),
+            "!" + (0, path_1.join)(cwd, "src/**/*.spec.ts"),
+            "!" + (0, path_1.join)(cwd, "src/**/*.test.ts"),
+            "!" + (0, path_1.join)(cwd, "src/**/*.d.ts"),
+        ];
+        var allSourcePaths = __spreadArray(__spreadArray([], defaultSourcePaths, true), additionalSourcePaths, true);
+        var loadStartTime = Date.now();
+        this.project.addSourceFilesAtPaths(allSourcePaths);
+        var loadTime = Date.now() - loadStartTime;
+        var fileCount = this.project.getSourceFiles().length;
+        perfLog.debug("\u2713 All source files loaded in ".concat(loadTime, "ms (").concat(fileCount, " files)"));
+        // Load config from flink.config.js
+        var flinkCfg = (0, loadFlinkConfig_1.loadFlinkConfig)(this.cwd);
+        this.compilerPlugins = (_c = flinkCfg === null || flinkCfg === void 0 ? void 0 : flinkCfg.compilerPlugins) !== null && _c !== void 0 ? _c : [];
+        this.disableServices = (_d = flinkCfg === null || flinkCfg === void 0 ? void 0 : flinkCfg.disableServices) !== null && _d !== void 0 ? _d : false;
+        if (this.compilerPlugins.length > 0) {
+            initLog.info("Compiler plugins loaded (".concat(this.compilerPlugins.length, "):"), this.compilerPlugins.map(function (p) { return "".concat(p.package, " \u2192 ").concat(p.scanDir); }).join(", "));
+        }
+        else {
+            initLog.info("No compiler plugins configured");
+        }
+        // Segment files by type for efficient processing
+        this.segmentSourceFiles();
         console.log("Loaded", this.project.getSourceFiles().length, "source file(s) from", cwd);
         console.log("Module system:", this.isEsm ? "ESM" : "CommonJS");
         console.log("Using module:", compilerOptions.module === ts_morph_1.ts.ModuleKind.ESNext ? "ESNext" : "CommonJS");
     }
+    /**
+     * Generates a schema $id from a file path and type name using the same algorithm
+     * as the schema generator's defineId callback.
+     *
+     * Examples:
+     * - src/schemas/Car.ts, "Car" → "Car"
+     * - src/schemas/wrappers/PartialLoginReq.ts, "PartialLoginReq" → "wrappers.PartialLoginReq"
+     * - src/schemas/PatchCarSchemas.ts, "PatchCarReq" → "PatchCarSchemas.PatchCarReq"
+     */
+    TypeScriptCompiler.prototype.filePathToSchemaId = function (absolutePath, typeName) {
+        var path = require("path");
+        var schemaDir = path.join(this.cwd, "src/schemas");
+        // Get path relative to src/schemas/
+        var relativePath = path.relative(schemaDir, absolutePath);
+        // Remove .ts extension
+        var pathWithoutExt = relativePath.replace(/\.ts$/, "");
+        // Split by path separator
+        var parts = pathWithoutExt.split(path.sep);
+        var fileName = parts[parts.length - 1];
+        // Root file with matching name: just type name
+        if (parts.length === 1 && fileName === typeName) {
+            return typeName;
+        }
+        // Nested file or multiple exports: include path
+        var pathPrefix = parts.join(".");
+        if (fileName === typeName) {
+            return pathPrefix; // Avoid duplication
+        }
+        return "".concat(pathPrefix, ".").concat(typeName);
+    };
+    /**
+     * Resolves a type name to its schema $id by looking up its import path.
+     * Returns undefined if the type is not imported from src/schemas/.
+     */
+    TypeScriptCompiler.prototype.resolveTypeNameToSchemaId = function (fileText, typeName, handlerFilePath) {
+        var path = require("path");
+        // Extract import statement for this type
+        var importStmt = schema_extraction_1.TypeScriptSourceParser.extractImportForType(fileText, typeName);
+        if (!importStmt) {
+            perfLog.trace("Type ".concat(typeName, " not found in imports"));
+            return undefined;
+        }
+        // Extract module specifier from import
+        // e.g., import { Foo } from "../schemas/Bar" → "../schemas/Bar"
+        var moduleMatch = importStmt.match(/from\s+["']([^"']+)["']/);
+        if (!moduleMatch) {
+            perfLog.trace("Could not extract module specifier from: ".concat(importStmt));
+            return undefined;
+        }
+        var moduleSpecifier = moduleMatch[1];
+        // Resolve relative import to absolute path
+        var handlerDir = path.dirname(handlerFilePath);
+        var importPath = path.resolve(handlerDir, moduleSpecifier);
+        // Add .ts extension if not present
+        var importPathWithExt = importPath.endsWith(".ts") ? importPath : importPath + ".ts";
+        // Check if this is from src/schemas/
+        var schemaDir = path.join(this.cwd, "src/schemas");
+        if (!importPathWithExt.startsWith(schemaDir)) {
+            perfLog.trace("Type ".concat(typeName, " is not from src/schemas/ (from ").concat(importPathWithExt, ")"));
+            return undefined;
+        }
+        // Generate schema $id using the same algorithm
+        return this.filePathToSchemaId(importPathWithExt, typeName);
+    };
+    /**
+     * Loads additional source paths from tsconfig.json's flink configuration.
+     * Allows projects to specify extra directories to include in compilation.
+     *
+     * Example tsconfig.json:
+     * {
+     *   "flink": {
+     *     "sourcePaths": ["src/custom-types/**\/*.ts", "src/utils/**\/*.ts"]
+     *   }
+     * }
+     */
+    TypeScriptCompiler.prototype.getFlinkSourcePaths = function (tsConfigPath) {
+        var _this = this;
+        try {
+            if (fs_1.default.existsSync(tsConfigPath)) {
+                var tsConfigContent = fs_1.default.readFileSync(tsConfigPath, "utf8");
+                var tsConfig = JSON.parse(tsConfigContent);
+                if (tsConfig.flink && Array.isArray(tsConfig.flink.sourcePaths)) {
+                    console.log("Found Flink-specific source paths:", tsConfig.flink.sourcePaths);
+                    return tsConfig.flink.sourcePaths.map(function (path) { return (0, path_1.join)(_this.cwd, path); });
+                }
+            }
+        }
+        catch (error) {
+            console.warn("Error reading Flink source paths from tsconfig.json:", error);
+        }
+        return [];
+    };
+    /**
+     * Initializes the schema generator.
+     *
+     * Note: ts-source-to-json-schema is ESM-only while @flink-app/flink is CommonJS.
+     * We use new Function() to preserve the actual import() in compiled output.
+     * Without this, TypeScript converts import() to require() which can't load ESM.
+     */
+    TypeScriptCompiler.prototype.initSchemaGenerator = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var dynamicImport, module_1, error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.schemaGenerator !== undefined) {
+                            return [2 /*return*/]; // Already initialized
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        dynamicImport = new Function("specifier", "return import(specifier)");
+                        return [4 /*yield*/, dynamicImport("@flink-app/ts-source-to-json-schema")];
+                    case 2:
+                        module_1 = _a.sent();
+                        if (typeof module_1.toJsonSchemasFromFile !== "function") {
+                            throw new Error("toJsonSchemasFromFile function not found. Please update @flink-app/ts-source-to-json-schema to >= 0.2.0");
+                        }
+                        this.schemaGenerator = module_1.toJsonSchemasFromFile;
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_1 = _a.sent();
+                        console.error("\n❌ Schema generator could not be loaded:\n" +
+                            "   Error: ".concat(error_1.message, "\n") +
+                            "\n💡 Make sure @flink-app/ts-source-to-json-schema is installed:\n" +
+                            "   npm install @flink-app/ts-source-to-json-schema\n");
+                        process.exit(1);
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Recursively resolves and adds imported files to the project.
+     * This ensures that files imported by handlers, schemas, etc. are available for type resolution.
+     *
+     * Handles three types of imports:
+     * 1. Relative imports (./foo, ../bar) - always resolved
+     * 2. Workspace package imports (@mycompany/shared) - resolved if symlinked outside node_modules
+     * 3. External packages (lodash, express) - skipped to avoid loading entire dependency trees
+     */
+    TypeScriptCompiler.prototype.resolveImportedFiles = function () {
+        // TODO: Check if this really is needed!
+        var processedFiles = new Set();
+        var filesToProcess = __spreadArray([], this.project.getSourceFiles(), true);
+        var totalImports = 0;
+        var skippedImports = 0;
+        var resolvedImports = 0;
+        while (filesToProcess.length > 0) {
+            var sourceFile = filesToProcess.pop();
+            var filePath = sourceFile.getFilePath();
+            if (processedFiles.has(filePath)) {
+                continue;
+            }
+            processedFiles.add(filePath);
+            // Get all import declarations
+            var importDeclarations = sourceFile.getImportDeclarations();
+            for (var _i = 0, importDeclarations_1 = importDeclarations; _i < importDeclarations_1.length; _i++) {
+                var importDecl = importDeclarations_1[_i];
+                var moduleSpecifier = importDecl.getModuleSpecifierValue();
+                totalImports++;
+                // For relative imports (./foo, ../bar), always resolve
+                var isRelativeImport = moduleSpecifier.startsWith(".") || moduleSpecifier.startsWith("/");
+                // For package imports, check if it might be a workspace package
+                // Workspace packages are typically scoped (@company/pkg) or match the workspace pattern
+                var isLikelyWorkspacePackage = !isRelativeImport && (moduleSpecifier.startsWith("@" + this.getWorkspaceScope() + "/") || this.isLikelyWorkspaceImport(moduleSpecifier));
+                // Skip resolution for external packages (performance optimization)
+                // Only resolve relative imports and likely workspace packages
+                if (!isRelativeImport && !isLikelyWorkspacePackage) {
+                    skippedImports++;
+                    continue;
+                }
+                // Try to resolve the imported file (expensive operation)
+                resolvedImports++;
+                var moduleSourceFile = importDecl.getModuleSpecifierSourceFile();
+                if (moduleSourceFile) {
+                    var importedPath = moduleSourceFile.getFilePath();
+                    // Double-check it's not in node_modules (for workspace packages)
+                    var isWorkspacePackage = !isRelativeImport && !importedPath.includes("node_modules");
+                    // Add to processing queue if it's a relative import or workspace package
+                    if ((isRelativeImport || isWorkspacePackage) && !processedFiles.has(importedPath)) {
+                        filesToProcess.push(moduleSourceFile);
+                    }
+                }
+            }
+        }
+        console.log("Resolved imports, total files loaded:", processedFiles.size);
+        console.log("  Import stats: ".concat(totalImports, " total, ").concat(skippedImports, " skipped, ").concat(resolvedImports, " resolved"));
+    };
+    /**
+     * Gets the workspace scope from package.json (e.g., "@mycompany" from "@mycompany/my-app")
+     * Returns empty string if not a scoped package.
+     */
+    TypeScriptCompiler.prototype.getWorkspaceScope = function () {
+        try {
+            var packageJson = JSON.parse(fs_1.default.readFileSync((0, path_1.join)(this.cwd, "package.json"), "utf8"));
+            var name = packageJson.name || "";
+            if (name.startsWith("@")) {
+                return name.split("/")[0].substring(1); // Remove @ and get scope
+            }
+        }
+        catch (error) {
+            // Ignore errors
+        }
+        return "";
+    };
+    /**
+     * Checks if an import is likely to be a workspace package.
+     * This is a heuristic - we check for common workspace patterns but can't be 100% sure
+     * without actually resolving. This is a performance optimization to avoid resolving
+     * obvious external packages like "express", "lodash", etc.
+     */
+    TypeScriptCompiler.prototype.isLikelyWorkspaceImport = function (moduleSpecifier) {
+        // If it contains a workspace marker in the name, it might be workspace
+        // Common patterns: starts with project name, contains "internal", etc.
+        // For now, be conservative and return false - only workspace packages with
+        // matching scope will be resolved
+        return false;
+    };
+    /**
+     * Segments source files by type for efficient processing.
+     * Performs all path checks and AST inspections in a single pass.
+     *
+     * This runs once during construction and caches results to avoid
+     * multiple full-file iterations during parse methods.
+     */
+    TypeScriptCompiler.prototype.segmentSourceFiles = function () {
+        var _a;
+        var startTime = Date.now();
+        var allFiles = this.project.getSourceFiles();
+        var handlerTime = 0, repoTime = 0, toolTime = 0, agentTime = 0, jobTime = 0, serviceTime = 0;
+        for (var _i = 0, allFiles_1 = allFiles; _i < allFiles_1.length; _i++) {
+            var sf = allFiles_1[_i];
+            var filePath = sf.getFilePath();
+            var fileStartTime = Date.now();
+            // Handlers: simple path check
+            if (filePath.includes("src/handlers/")) {
+                this.handlerFiles.push(sf);
+                handlerTime += Date.now() - fileStartTime;
+                continue; // Skip further checks (mutually exclusive)
+            }
+            // Repos: simple path check
+            if (filePath.includes("src/repos/")) {
+                this.repoFiles.push(sf);
+                repoTime += Date.now() - fileStartTime;
+                continue;
+            }
+            // Tools: path check + fast text-based detection
+            // Check if file contains "FlinkToolProps" without parsing AST (much faster)
+            if (filePath.includes("src/tools/")) {
+                var fileText = sf.getFullText();
+                // Fast text check: must have both "export" and ": FlinkToolProps"
+                if (fileText.includes("FlinkToolProps") && fileText.includes("export")) {
+                    this.toolFiles.push(sf);
+                    // Extract tool ID using regex (faster than AST inspection)
+                    // Matches: id: "tool-name" or name: "tool-name"
+                    var idMatch = fileText.match(/(?:id|name):\s*["']([^"']+)["']/);
+                    if (idMatch) {
+                        this.toolIdRegistry.add(idMatch[1]);
+                    }
+                }
+                toolTime += Date.now() - fileStartTime;
+                continue;
+            }
+            // Agents: convention-based detection (all .ts files in src/agents/)
+            // Trust that files in src/agents/ are valid agents - validate at runtime
+            if (filePath.includes("src/agents/")) {
+                this.agentFiles.push(sf);
+                agentTime += Date.now() - fileStartTime;
+                continue;
+            }
+            // Jobs: simple path check
+            if (filePath.includes("src/jobs/")) {
+                this.jobFiles.push(sf);
+                jobTime += Date.now() - fileStartTime;
+                continue;
+            }
+            // Services: simple path check (opt-out via flink.config.js disableServices)
+            if (!this.disableServices && filePath.includes("src/services/")) {
+                this.serviceFiles.push(sf);
+                serviceTime += Date.now() - fileStartTime;
+                continue;
+            }
+            // Extension dirs from compiler plugins
+            for (var _b = 0, _c = this.compilerPlugins; _b < _c.length; _b++) {
+                var ext = _c[_b];
+                if (filePath.includes(ext.scanDir)) {
+                    if (!ext.detectBy || ext.detectBy(sf.getFullText(), filePath)) {
+                        var list = (_a = this.extensionFiles.get(ext.generatedFile)) !== null && _a !== void 0 ? _a : [];
+                        list.push(sf);
+                        this.extensionFiles.set(ext.generatedFile, list);
+                    }
+                    break;
+                }
+            }
+        }
+        var segmentTime = Date.now() - startTime;
+        perfLog.debug("\u2713 File segmentation completed in ".concat(segmentTime, "ms ") +
+            "(".concat(this.handlerFiles.length, " handlers, ").concat(this.repoFiles.length, " repos, ").concat(this.toolFiles.length, " tools, ").concat(this.agentFiles.length, " agents, ").concat(this.jobFiles.length, " jobs, ").concat(this.serviceFiles.length, " services)"));
+    };
     /**
      * Detects if the project is using ESM (ECMAScript Modules)
      * by checking type in package.json.
@@ -156,14 +538,29 @@ var TypeScriptCompiler = /** @class */ (function () {
     };
     /**
      * Gets the module specifier for imports, adding .js extension for ESM
+     * Uses fast path calculation instead of ts-morph's getRelativePathAsModuleSpecifierTo
+     * which triggers expensive language service initialization
      */
     TypeScriptCompiler.prototype.getModuleSpecifier = function (fromFile, toFile) {
-        var moduleSpecifier = fromFile.getRelativePathAsModuleSpecifierTo(toFile);
-        // Add .js extension for ESM imports (only for relative paths)
-        if (this.isEsm && !moduleSpecifier.startsWith("@") && !moduleSpecifier.endsWith(".js")) {
-            moduleSpecifier += ".js";
+        var path = require("path");
+        // Get directory paths
+        var fromDir = path.dirname(fromFile.getFilePath());
+        var toPath = toFile.getFilePath();
+        // Calculate relative path
+        var relativePath = path.relative(fromDir, toPath);
+        // Convert to forward slashes (module specifiers use forward slashes)
+        relativePath = relativePath.replace(/\\/g, "/");
+        // Remove .ts extension
+        relativePath = relativePath.replace(/\.ts$/, "");
+        // Ensure it starts with ./ or ../
+        if (!relativePath.startsWith(".")) {
+            relativePath = "./" + relativePath;
+        }
+        // Add .js extension for ESM imports
+        if (this.isEsm) {
+            relativePath += ".js";
         }
-        return moduleSpecifier;
+        return relativePath;
     };
     /**
      * Deletes all generated files.
@@ -210,10 +607,136 @@ var TypeScriptCompiler = /** @class */ (function () {
         });
     };
     /**
-     * Emits compiled javascript source to dist folder
+     * Saves all modified source files in a single batch operation.
+     * Call this before emit() to persist all changes to disk.
+     */
+    TypeScriptCompiler.prototype.saveAllModifiedFiles = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var startTime, flinkFiles, unsavedFlinkFiles, saveTime;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        startTime = Date.now();
+                        flinkFiles = this.project.getSourceFiles("**/.flink/**/*.ts");
+                        unsavedFlinkFiles = flinkFiles.filter(function (sf) { return !sf.isSaved(); });
+                        return [4 /*yield*/, Promise.all(unsavedFlinkFiles.map(function (sf) { return sf.save(); }))];
+                    case 1:
+                        _a.sent();
+                        saveTime = Date.now() - startTime;
+                        perfLog.debug("\u2713 Batch save completed in ".concat(saveTime, "ms (").concat(unsavedFlinkFiles.length, " files)"));
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Emits compiled javascript source to dist folder using swc (20-50x faster than tsc)
+     */
+    TypeScriptCompiler.prototype.emitWithSwc = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var emitStartTime, swc, fs, path, allSourceFiles, emitTime;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        emitStartTime = Date.now();
+                        swc = require("@swc/core");
+                        fs = require("fs-extra");
+                        path = require("path");
+                        allSourceFiles = this.project.getSourceFiles().filter(function (sf) {
+                            var filePath = sf.getFilePath();
+                            return !filePath.endsWith(".d.ts") && !filePath.includes("/node_modules/");
+                        });
+                        initLog.debug("Starting swc compilation for ".concat(allSourceFiles.length, " source files..."));
+                        // Transpile all files in parallel using swc
+                        return [4 /*yield*/, Promise.all(allSourceFiles.map(function (sf) { return __awaiter(_this, void 0, void 0, function () {
+                                var filePath, code, result, relativePath, outPath;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            filePath = sf.getFilePath();
+                                            code = sf.getFullText();
+                                            return [4 /*yield*/, swc.transform(code, {
+                                                    filename: filePath,
+                                                    jsc: {
+                                                        parser: {
+                                                            syntax: "typescript",
+                                                            decorators: true,
+                                                            tsx: false, // Flink doesn't use JSX
+                                                        },
+                                                        target: "es2017", // Async/await support, modern enough for Node 14+
+                                                        transform: {
+                                                            legacyDecorator: true,
+                                                            decoratorMetadata: true, // Required for reflect-metadata
+                                                        },
+                                                        keepClassNames: true, // Preserve class names for debugging
+                                                    },
+                                                    module: {
+                                                        type: this.isEsm ? "es6" : "commonjs",
+                                                    },
+                                                    sourceMaps: true,
+                                                })];
+                                        case 1:
+                                            result = _a.sent();
+                                            relativePath = path.relative(this.cwd, filePath);
+                                            outPath = path.join(this.cwd, "dist", relativePath).replace(/\.ts$/, ".js");
+                                            return [4 /*yield*/, fs.ensureDir(path.dirname(outPath))];
+                                        case 2:
+                                            _a.sent();
+                                            return [4 /*yield*/, fs.writeFile(outPath, result.code)];
+                                        case 3:
+                                            _a.sent();
+                                            if (!result.map) return [3 /*break*/, 5];
+                                            return [4 /*yield*/, fs.writeFile(outPath + ".map", result.map)];
+                                        case 4:
+                                            _a.sent();
+                                            _a.label = 5;
+                                        case 5: return [2 /*return*/];
+                                    }
+                                });
+                            }); }))];
+                    case 1:
+                        // Transpile all files in parallel using swc
+                        _a.sent();
+                        emitTime = Date.now() - emitStartTime;
+                        initLog.debug("\u2713 Emitted ".concat(allSourceFiles.length, " files with swc in ").concat(emitTime, "ms (").concat((emitTime / allSourceFiles.length).toFixed(1), "ms per file)"));
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Emits compiled javascript source to dist folder (defaults to swc for speed, falls back to tsc)
      */
     TypeScriptCompiler.prototype.emit = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 3]);
+                        require.resolve("@swc/core");
+                        return [4 /*yield*/, this.emitWithSwc()];
+                    case 1: return [2 /*return*/, _b.sent()];
+                    case 2:
+                        _a = _b.sent();
+                        initLog.debug("@swc/core not found, falling back to TypeScript compiler (slower)");
+                        return [2 /*return*/, this.emitWithTsc()];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Emits compiled javascript source to dist folder using TypeScript compiler (slower, kept for fallback)
+     */
+    TypeScriptCompiler.prototype.emitWithTsc = function () {
+        var emitStartTime = Date.now();
+        var sourceFileCount = this.project.getSourceFiles().length;
+        perfLog.debug("Starting TypeScript compilation for ".concat(sourceFileCount, " source files..."));
         this.project.emitSync();
+        var emitTime = Date.now() - emitStartTime;
+        perfLog.debug("\u2713 Emitted ".concat(sourceFileCount, " files with tsc in ").concat(emitTime, "ms (").concat((emitTime / sourceFileCount).toFixed(1), "ms per file)"));
     };
     /**
      * Catch any compilation errors. Will return false if any Errors
@@ -253,28 +776,27 @@ var TypeScriptCompiler = /** @class */ (function () {
      * type arguments.
      */
     TypeScriptCompiler.prototype.parseHandlers = function () {
-        return __awaiter(this, arguments, void 0, function (excludeDirs) {
-            var generatedFile, handlersArr, handlers, schemaFilePath, jsonSchemas;
-            if (excludeDirs === void 0) { excludeDirs = []; }
+        return __awaiter(this, void 0, void 0, function () {
+            var startTime, generatedFile, handlersArr, handlers, handlerParseTime;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
+                        startTime = Date.now();
                         generatedFile = this.createSourceFile(["generatedHandlers.ts"], "// Generated ".concat(new Date(), "\nimport { autoRegisteredHandlers, HttpMethod } from \"@flink-app/flink\";\nexport const handlers = [];\nautoRegisteredHandlers.push(...handlers);\n    "));
                         handlersArr = generatedFile.getVariableDeclarationOrThrow("handlers").getFirstDescendantByKindOrThrow(ts_morph_1.SyntaxKind.ArrayLiteralExpression);
                         return [4 /*yield*/, this.parseHandlerDir(generatedFile, handlersArr)];
                     case 1:
                         handlers = _a.sent();
                         generatedFile.addImportDeclarations(handlers.imports);
-                        return [4 /*yield*/, generatedFile.save()];
-                    case 2:
-                        _a.sent();
-                        return [4 /*yield*/, this.createIntermediateSchemaFile()];
-                    case 3:
-                        schemaFilePath = _a.sent();
-                        return [4 /*yield*/, this.generateAndSaveJsonSchemas(handlers.schemasToGenerate, schemaFilePath)];
-                    case 4:
-                        jsonSchemas = _a.sent();
-                        this.appendSchemasToHandlerSourceFiles(handlers.schemasToGenerate, jsonSchemas);
+                        // Defer save until batch save at end (performance optimization)
+                        // Store handler schemas for later batch processing
+                        this.handlerSchemasToGenerate = handlers.schemasToGenerate;
+                        // Cleanup: forget handler file nodes to reduce memory overhead (ts-morph performance optimization)
+                        this.handlerFiles.forEach(function (sf) {
+                            sf.getClasses().forEach(function (cls) { return cls.forget(); });
+                        });
+                        handlerParseTime = Date.now() - startTime;
+                        perfLog.info("\u2713 Handler parsing completed in ".concat(handlerParseTime, "ms"));
                         return [2 /*return*/, generatedFile];
                 }
             });
@@ -285,129 +807,342 @@ var TypeScriptCompiler = /** @class */ (function () {
      */
     TypeScriptCompiler.prototype.parseHandlerDir = function (generatedFile, handlersArr) {
         return __awaiter(this, void 0, void 0, function () {
-            var imports, i, schemasToGenerate, _i, _a, sf, isAutoRegister, namespaceImport, assumedHttpMethod, schemaTypes, _b, existingVars;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
+            var imports, schemasToGenerate, handlerFiles, handlerResults, handlerElements, _i, handlerResults_1, result, sf, isAutoRegister, namespaceImport, assumedHttpMethod, schemaTypes;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
                     case 0:
                         imports = [];
-                        i = 0;
                         schemasToGenerate = [];
-                        _i = 0, _a = this.project.getSourceFiles();
-                        _c.label = 1;
+                        handlerFiles = this.handlerFiles;
+                        return [4 /*yield*/, Promise.all(handlerFiles.map(function (sf, index) { return __awaiter(_this, void 0, void 0, function () {
+                                var startTime, isAutoRegister, namespaceImport, assumedHttpMethod, schemaTypes, _a;
+                                return __generator(this, function (_b) {
+                                    switch (_b.label) {
+                                        case 0:
+                                            startTime = Date.now();
+                                            isAutoRegister = this.isAutoRegisterableHandler(sf);
+                                            namespaceImport = sf.getBaseNameWithoutExtension().replace(/\./g, "_") + "_" + index;
+                                            assumedHttpMethod = (0, utils_1.getHttpMethodFromHandlerName)(sf.getBaseName());
+                                            if (!isAutoRegister) return [3 /*break*/, 2];
+                                            return [4 /*yield*/, this.extractSchemasFromHandlerFast(sf.getFilePath())];
+                                        case 1:
+                                            _a = _b.sent();
+                                            return [3 /*break*/, 3];
+                                        case 2:
+                                            _a = undefined;
+                                            _b.label = 3;
+                                        case 3:
+                                            schemaTypes = _a;
+                                            perfLog.trace("".concat(sf.getBaseName(), " took ").concat(Date.now() - startTime, "ms"));
+                                            return [2 /*return*/, {
+                                                    sf: sf,
+                                                    isAutoRegister: isAutoRegister,
+                                                    namespaceImport: namespaceImport,
+                                                    assumedHttpMethod: assumedHttpMethod,
+                                                    schemaTypes: schemaTypes,
+                                                    index: index,
+                                                }];
+                                    }
+                                });
+                            }); }))];
                     case 1:
-                        if (!(_i < _a.length)) return [3 /*break*/, 6];
-                        sf = _a[_i];
-                        if (!sf.getFilePath().includes("src/handlers/")) {
-                            return [3 /*break*/, 5];
-                        }
-                        isAutoRegister = this.isAutoRegisterableHandler(sf);
-                        console.log("Detected handler ".concat(sf.getBaseName(), " ").concat(!isAutoRegister ? "(requires manual registration)" : ""));
-                        namespaceImport = sf.getBaseNameWithoutExtension().replace(/\./g, "_") + "_" + i;
-                        imports.push({
-                            defaultImport: "* as " + namespaceImport,
-                            moduleSpecifier: this.getModuleSpecifier(generatedFile, sf),
-                        });
-                        assumedHttpMethod = (0, utils_1.getHttpMethodFromHandlerName)(sf.getBaseName());
-                        if (!isAutoRegister) return [3 /*break*/, 3];
-                        return [4 /*yield*/, this.extractSchemasFromHandlerSourceFile(sf)];
-                    case 2:
-                        _b = _c.sent();
-                        return [3 /*break*/, 4];
-                    case 3:
-                        _b = undefined;
-                        _c.label = 4;
-                    case 4:
-                        schemaTypes = _b;
-                        existingVars = sf.getVariableStatements().filter(function (vs) {
-                            var varNames = vs.getDeclarations().map(function (d) { return d.getName(); });
-                            return varNames.some(function (name) { return ["__assumedHttpMethod", "__file", "__query", "__params"].includes(name); });
-                        });
-                        existingVars.forEach(function (v) { return v.remove(); });
-                        // Append schemas and metadata to source file that will be part of emitted dist bundle (javascript)
-                        sf.addVariableStatement({
-                            declarationKind: ts_morph_1.VariableDeclarationKind.Const,
-                            isExported: true,
-                            declarations: [
-                                {
-                                    name: "__assumedHttpMethod",
-                                    initializer: "\"".concat(assumedHttpMethod || "", "\""),
-                                },
-                                {
-                                    name: "__file",
-                                    initializer: "\"".concat(sf.getBaseName(), "\""),
-                                },
-                                {
-                                    name: "__query",
-                                    initializer: "[".concat(((schemaTypes === null || schemaTypes === void 0 ? void 0 : schemaTypes.queryMetadata) || [])
-                                        .map(function (_a) {
-                                        var description = _a.description, name = _a.name;
-                                        return "{description: \"".concat(description, "\", name: \"").concat(name, "\"}");
-                                    })
-                                        .join(","), "]"),
-                                },
-                                {
-                                    name: "__params",
-                                    initializer: "[".concat(((schemaTypes === null || schemaTypes === void 0 ? void 0 : schemaTypes.paramsMetadata) || [])
-                                        .map(function (_a) {
-                                        var description = _a.description, name = _a.name;
-                                        return "{description: \"".concat(description, "\", name: \"").concat(name, "\"}");
-                                    })
-                                        .join(","), "]"),
-                                },
-                            ],
-                        });
-                        if (isAutoRegister) {
-                            handlersArr.insertElement(i, "{handler: ".concat(namespaceImport, ", assumedHttpMethod: ").concat(assumedHttpMethod ? "HttpMethod." + assumedHttpMethod : undefined, "}"));
-                            i++;
-                            // Add schemas to generate list
-                            if (schemaTypes) {
-                                schemasToGenerate.push(__assign(__assign({}, schemaTypes), { sourceFile: sf }));
+                        handlerResults = _a.sent();
+                        handlerElements = [];
+                        for (_i = 0, handlerResults_1 = handlerResults; _i < handlerResults_1.length; _i++) {
+                            result = handlerResults_1[_i];
+                            sf = result.sf, isAutoRegister = result.isAutoRegister, namespaceImport = result.namespaceImport, assumedHttpMethod = result.assumedHttpMethod, schemaTypes = result.schemaTypes;
+                            imports.push({
+                                defaultImport: "* as " + namespaceImport,
+                                moduleSpecifier: this.getModuleSpecifier(generatedFile, sf),
+                            });
+                            if (isAutoRegister) {
+                                handlerElements.push("{handler: ".concat(namespaceImport, ", assumedHttpMethod: ").concat(assumedHttpMethod ? "HttpMethod." + assumedHttpMethod : undefined, ", __file: \"").concat(this.getRelativePath(sf), "\"}"));
+                                // Add schemas to generate list
+                                if (schemaTypes) {
+                                    schemasToGenerate.push(__assign(__assign({}, schemaTypes), { sourceFile: sf }));
+                                }
                             }
                         }
-                        _c.label = 5;
-                    case 5:
-                        _i++;
-                        return [3 /*break*/, 1];
-                    case 6: return [2 /*return*/, {
-                            imports: imports,
-                            schemasToGenerate: schemasToGenerate,
-                        }];
+                        // Add all handler elements in one batch operation
+                        handlersArr.addElements(handlerElements);
+                        return [2 /*return*/, {
+                                imports: imports,
+                                schemasToGenerate: schemasToGenerate,
+                            }];
                 }
             });
         });
     };
     TypeScriptCompiler.prototype.parseRepos = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var generatedFile, reposArr, imports, i, _i, _a, sf;
+            var startTime, generatedFile, reposArr, imports, repoFiles, repoElements, _i, repoFiles_1, sf, repoParseTime;
+            return __generator(this, function (_a) {
+                startTime = Date.now();
+                generatedFile = this.createSourceFile(["generatedRepos.ts"], "// Generated ".concat(new Date(), "\n  import { autoRegisteredRepos } from \"@flink-app/flink\";\n  export const repos = [];\n  autoRegisteredRepos.push(...repos);\n      "));
+                reposArr = generatedFile.getVariableDeclarationOrThrow("repos").getFirstDescendantByKindOrThrow(ts_morph_1.SyntaxKind.ArrayLiteralExpression);
+                imports = [];
+                repoFiles = this.repoFiles;
+                repoElements = [];
+                for (_i = 0, repoFiles_1 = repoFiles; _i < repoFiles_1.length; _i++) {
+                    sf = repoFiles_1[_i];
+                    console.log("Detected repo ".concat(sf.getBaseName()));
+                    imports.push({
+                        defaultImport: sf.getBaseNameWithoutExtension(),
+                        moduleSpecifier: this.getModuleSpecifier(generatedFile, sf),
+                    });
+                    repoElements.push("{collectionName: \"".concat((0, utils_1.getCollectionNameForRepo)(sf.getBaseName()), "\", repoInstanceName: \"").concat((0, utils_1.getRepoInstanceName)(sf.getBaseName()), "\", Repo: ").concat(sf.getBaseNameWithoutExtension(), "}"));
+                }
+                // Add all repo elements in one batch operation
+                reposArr.addElements(repoElements);
+                generatedFile.addImportDeclarations(imports);
+                // Defer save until batch save at end (performance optimization)
+                // Cleanup: forget repo file nodes to reduce memory overhead (ts-morph performance optimization)
+                this.repoFiles.forEach(function (sf) {
+                    sf.getClasses().forEach(function (cls) { return cls.forget(); });
+                });
+                repoParseTime = Date.now() - startTime;
+                initLog.info("\u2713 Repo parsing completed in ".concat(repoParseTime, "ms (").concat(repoElements.length, " repos)"));
+                return [2 /*return*/, generatedFile];
+            });
+        });
+    };
+    /**
+     * Scans project for tools and adds those to Flink
+     * "singleton" property `autoRegisteredTools` so they can
+     * be registered during start.
+     *
+     * Also extracts input and output schemas from FlinkTool type arguments
+     * when manual schemas are not provided.
+     */
+    TypeScriptCompiler.prototype.parseTools = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var startTime, generatedFile, toolsArr, imports, schemasToGenerate, toolFiles, toolResults, _loop_1, index, _i, toolResults_1, result, schemaTypes, toolParseTime, toolElements, _a, toolResults_2, result, sf, namespaceImport, toolPropsExportName, schemaTypes;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
-                        generatedFile = this.createSourceFile(["generatedRepos.ts"], "// Generated ".concat(new Date(), "\n  import { autoRegisteredRepos } from \"@flink-app/flink\";\n  export const repos = [];\n  autoRegisteredRepos.push(...repos);\n      "));
-                        reposArr = generatedFile.getVariableDeclarationOrThrow("repos").getFirstDescendantByKindOrThrow(ts_morph_1.SyntaxKind.ArrayLiteralExpression);
+                        startTime = Date.now();
+                        // Initialize schema generator BEFORE schema extraction
+                        return [4 /*yield*/, this.initSchemaGenerator()];
+                    case 1:
+                        // Initialize schema generator BEFORE schema extraction
+                        _b.sent();
+                        generatedFile = this.createSourceFile(["generatedTools.ts"], "// Generated ".concat(new Date(), "\nimport { autoRegisteredTools } from \"@flink-app/flink\";\nexport const tools = [];\nautoRegisteredTools.push(...tools);\n    "));
+                        toolsArr = generatedFile.getVariableDeclarationOrThrow("tools").getFirstDescendantByKindOrThrow(ts_morph_1.SyntaxKind.ArrayLiteralExpression);
                         imports = [];
-                        i = 0;
-                        for (_i = 0, _a = this.project.getSourceFiles(); _i < _a.length; _i++) {
-                            sf = _a[_i];
-                            if (!sf.getFilePath().includes("src/repos/")) {
-                                continue;
-                            }
-                            console.log("Detected repo ".concat(sf.getBaseName()));
+                        schemasToGenerate = [];
+                        toolFiles = this.toolFiles;
+                        toolResults = [];
+                        _loop_1 = function (index) {
+                            var sf = toolFiles[index];
+                            (function () {
+                                // Get file path ONCE and cache it to avoid triggering ts-morph lazy parsing
+                                var filePath = sf.getFilePath();
+                                var path = require("path");
+                                var baseNameWithoutExt = path.basename(filePath, path.extname(filePath));
+                                var namespaceImport = baseNameWithoutExt.replace(/\./g, "_") + "_" + index;
+                                // Extract the export name using fast text matching instead of AST parsing
+                                // Read file directly from disk to avoid ts-morph's lazy parsing
+                                // Matches: export const Tool: FlinkToolProps or export const MyName: FlinkToolProps
+                                var fileText = fs_1.default.readFileSync(filePath, "utf8");
+                                var exportMatch = fileText.match(/export\s+const\s+(\w+)\s*:\s*FlinkToolProps/);
+                                var toolPropsExportName = exportMatch ? exportMatch[1] : "Tool"; // Default to "Tool" if not found
+                                toolResults.push({
+                                    sf: sf,
+                                    filePath: filePath, // Cache file path to avoid triggering sf.getFilePath() later
+                                    namespaceImport: namespaceImport,
+                                    toolPropsExportName: toolPropsExportName,
+                                    index: index,
+                                });
+                            })();
+                        };
+                        for (index = 0; index < toolFiles.length; index++) {
+                            _loop_1(index);
+                        }
+                        _i = 0, toolResults_1 = toolResults;
+                        _b.label = 2;
+                    case 2:
+                        if (!(_i < toolResults_1.length)) return [3 /*break*/, 5];
+                        result = toolResults_1[_i];
+                        return [4 /*yield*/, this.extractSchemasFromToolFast(result.filePath)];
+                    case 3:
+                        schemaTypes = _b.sent();
+                        schemasToGenerate.push({
+                            inputSchemaType: schemaTypes === null || schemaTypes === void 0 ? void 0 : schemaTypes.inputSchemaType,
+                            outputSchemaType: schemaTypes === null || schemaTypes === void 0 ? void 0 : schemaTypes.outputSchemaType,
+                            inputTypeHint: schemaTypes === null || schemaTypes === void 0 ? void 0 : schemaTypes.inputTypeHint,
+                            outputTypeHint: schemaTypes === null || schemaTypes === void 0 ? void 0 : schemaTypes.outputTypeHint,
+                            sourceFile: result.sf,
+                        });
+                        _b.label = 4;
+                    case 4:
+                        _i++;
+                        return [3 /*break*/, 2];
+                    case 5:
+                        toolParseTime = Date.now() - startTime;
+                        initLog.info("\u2713 Tool parsing completed in ".concat(toolParseTime, "ms (").concat(toolFiles.length, " tools)"));
+                        toolElements = [];
+                        for (_a = 0, toolResults_2 = toolResults; _a < toolResults_2.length; _a++) {
+                            result = toolResults_2[_a];
+                            sf = result.sf, namespaceImport = result.namespaceImport, toolPropsExportName = result.toolPropsExportName, schemaTypes = result.schemaTypes;
                             imports.push({
-                                defaultImport: sf.getBaseNameWithoutExtension(),
+                                defaultImport: "* as " + namespaceImport,
                                 moduleSpecifier: this.getModuleSpecifier(generatedFile, sf),
                             });
-                            reposArr.insertElement(i, "{collectionName: \"".concat((0, utils_1.getCollectionNameForRepo)(sf.getBaseName()), "\", repoInstanceName: \"").concat((0, utils_1.getRepoInstanceName)(sf.getBaseName()), "\", Repo: ").concat(sf.getBaseNameWithoutExtension(), "}"));
-                            i++;
+                            // Create an object that wraps the namespace and provides normalized access to the tool props
+                            // This creates a consistent "Tool" property regardless of the source export name
+                            // Example: {Tool: SearchCarsTool_0.MyCustomToolConfig} works even if export was "MyCustomToolConfig"
+                            // __file is set here on the registration object (not injected into source files)
+                            toolElements.push("{...".concat(namespaceImport, ", Tool: ").concat(namespaceImport, ".").concat(toolPropsExportName, ", __file: \"").concat(this.getRelativePath(sf), "\"}"));
+                            // Add schemas to generate list
+                            if (schemaTypes) {
+                                schemasToGenerate.push(__assign(__assign({}, schemaTypes), { sourceFile: sf }));
+                            }
                         }
+                        // Add all tool elements in one batch operation
+                        toolsArr.addElements(toolElements);
                         generatedFile.addImportDeclarations(imports);
-                        return [4 /*yield*/, generatedFile.save()];
-                    case 1:
-                        _b.sent();
+                        // Defer save until batch save at end (performance optimization)
+                        // Store tool schemas for later batch processing
+                        this.toolSchemasToGenerate = schemasToGenerate;
+                        // Cleanup: forget tool file nodes to reduce memory overhead (ts-morph performance optimization)
+                        // Note: We avoid calling methods on sf during iteration since we cached all needed data earlier
+                        this.toolFiles.forEach(function (sf) {
+                            // Only forget if we haven't already processed this file
+                            var classes = sf.getClasses();
+                            classes.forEach(function (cls) { return cls.forget(); });
+                        });
                         return [2 /*return*/, generatedFile];
                 }
             });
         });
     };
+    /**
+     * Scans project for agents and validates tool references.
+     * Agents are classes extending FlinkAgent exported as default.
+     */
+    TypeScriptCompiler.prototype.parseAgents = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var startTime, generatedFile, agentsArr, imports, registeredToolIds, agentElements, agentParseTime;
+            var _this = this;
+            return __generator(this, function (_a) {
+                startTime = Date.now();
+                generatedFile = this.createSourceFile(["generatedAgents.ts"], "// Generated ".concat(new Date(), "\nimport { autoRegisteredAgents } from \"@flink-app/flink\";\nexport const agents = [];\nautoRegisteredAgents.push(...agents);\n    "));
+                agentsArr = generatedFile.getVariableDeclarationOrThrow("agents").getFirstDescendantByKindOrThrow(ts_morph_1.SyntaxKind.ArrayLiteralExpression);
+                imports = [];
+                registeredToolIds = this.toolIdRegistry;
+                agentElements = [];
+                // Use pre-segmented agent files (convention-based: all files in src/agents/ are agents)
+                this.agentFiles.forEach(function (sf, index) {
+                    var _a;
+                    // Convention-based approach: Trust that all files in src/agents/ are valid agents
+                    // Find the first exported class (assume it's the agent)
+                    var agentClass = sf.getClasses().find(function (cls) { return cls.isExported() || cls.isDefaultExport(); });
+                    // Skip if no exported class found (shouldn't happen, but defensive)
+                    if (!agentClass) {
+                        perfLog.debug("\u26A0 Skipping ".concat(sf.getBaseName(), " - no exported class found"));
+                        return;
+                    }
+                    // Create unique namespace import (same pattern as handlers and tools)
+                    var namespaceImport = sf.getBaseNameWithoutExtension().replace(/\./g, "_") + "_" + index;
+                    // Validate tool references exist (read from class properties)
+                    var toolsProperty = agentClass.getProperty("tools");
+                    if (toolsProperty) {
+                        var initializer = toolsProperty.getInitializer();
+                        if (initializer && initializer.getKind() === ts_morph_1.SyntaxKind.ArrayLiteralExpression) {
+                            var toolsArray = initializer;
+                            var toolElements = toolsArray.getElements();
+                            var _loop_2 = function (toolElement) {
+                                var toolName = void 0;
+                                // Handle string literals, method calls, and identifier references (tool imports)
+                                if (toolElement.getKind() === ts_morph_1.SyntaxKind.StringLiteral) {
+                                    // Direct string: "tool-name"
+                                    toolName = toolElement.getText().replace(/['"]/g, "");
+                                }
+                                else if (toolElement.getKind() === ts_morph_1.SyntaxKind.CallExpression) {
+                                    // Method call: this.useTool("tool-name")
+                                    var args = toolElement.getArguments();
+                                    if (args.length > 0 && args[0].getKind() === ts_morph_1.SyntaxKind.StringLiteral) {
+                                        toolName = args[0].getText().replace(/['"]/g, "");
+                                    }
+                                    else {
+                                        console.warn("Agent ".concat(sf.getBaseName(), " has non-string tool reference, skipping validation"));
+                                        return "continue";
+                                    }
+                                }
+                                else if (toolElement.getKind() === ts_morph_1.SyntaxKind.Identifier) {
+                                    // Tool file reference (imported): SearchCarsByBrandTool
+                                    // Look up the import to find the actual tool file
+                                    var importName_1 = toolElement.getText();
+                                    var importDecl = sf.getImportDeclarations().find(function (imp) {
+                                        var namedImports = imp.getNamedImports();
+                                        return namedImports.some(function (ni) { return ni.getName() === importName_1; });
+                                    });
+                                    if (!importDecl) {
+                                        // Try namespace import (* as Foo)
+                                        var namespaceImport_1 = sf.getImportDeclarations().find(function (imp) {
+                                            var _a;
+                                            return ((_a = imp.getNamespaceImport()) === null || _a === void 0 ? void 0 : _a.getText()) === importName_1;
+                                        });
+                                        if (namespaceImport_1) {
+                                            var moduleSpecifier = namespaceImport_1.getModuleSpecifierValue();
+                                            // Extract tool ID from the tool file path
+                                            // e.g., "../tools/SearchCarsByBrandTool" -> find in registeredToolIds
+                                            var toolFileName = (_a = moduleSpecifier.split("/").pop()) === null || _a === void 0 ? void 0 : _a.replace(/\.ts$/, "");
+                                            var matchingTool = Array.from(registeredToolIds).find(function (id) {
+                                                // Try to match by searching for the tool ID
+                                                // This is a heuristic - we'll validate it exists
+                                                return true; // Skip validation for imported tools for now
+                                            });
+                                            return "continue";
+                                        }
+                                        console.warn("Agent ".concat(sf.getBaseName(), " references tool \"").concat(importName_1, "\" but it's not imported, skipping validation"));
+                                        return "continue";
+                                    }
+                                    return "continue";
+                                }
+                                else {
+                                    console.warn("Agent ".concat(sf.getBaseName(), " has unexpected tool reference format: ").concat(toolElement.getText()));
+                                    return "continue";
+                                }
+                                if (!registeredToolIds.has(toolName)) {
+                                    console.error("Agent ".concat(sf.getBaseName(), " references tool \"").concat(toolName, "\" which does not exist"));
+                                    throw new Error("Invalid tool reference in agent ".concat(sf.getBaseName()));
+                                }
+                            };
+                            for (var _i = 0, toolElements_1 = toolElements; _i < toolElements_1.length; _i++) {
+                                var toolElement = toolElements_1[_i];
+                                _loop_2(toolElement);
+                            }
+                        }
+                    }
+                    var className = agentClass.getName();
+                    if (!className) {
+                        console.error("Agent class in ".concat(sf.getBaseName(), " has no name"));
+                        return;
+                    }
+                    imports.push({
+                        defaultImport: "* as " + namespaceImport,
+                        moduleSpecifier: _this.getModuleSpecifier(generatedFile, sf),
+                    });
+                    // Register the agent class (access default export via namespace)
+                    // __file is set here on the registration object (not injected into source files)
+                    agentElements.push("{ default: ".concat(namespaceImport, ".default, __file: \"").concat(_this.getRelativePath(sf), "\" }"));
+                });
+                // Add all agent elements in one batch operation
+                agentsArr.addElements(agentElements);
+                generatedFile.addImportDeclarations(imports);
+                // Defer save until batch save at end (performance optimization)
+                // Cleanup: forget agent file nodes to reduce memory overhead (ts-morph performance optimization)
+                this.agentFiles.forEach(function (sf) {
+                    sf.getClasses().forEach(function (cls) { return cls.forget(); });
+                });
+                agentParseTime = Date.now() - startTime;
+                initLog.info("\u2713 Agent parsing completed in ".concat(agentParseTime, "ms (").concat(agentElements.length, " agents)"));
+                return [2 /*return*/, generatedFile];
+            });
+        });
+    };
     /**
      * Generates a start script that will import references to handlers, repos and the
      * actual Flink app to start.
@@ -417,19 +1152,37 @@ var TypeScriptCompiler = /** @class */ (function () {
      */
     TypeScriptCompiler.prototype.generateStartScript = function () {
         return __awaiter(this, arguments, void 0, function (appEntryScript) {
-            var sf;
+            var path, entryScriptPath, specFiles, extensionImports, sf;
+            var _this = this;
             if (appEntryScript === void 0) { appEntryScript = "/src/index.ts"; }
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        if (!this.project.getSourceFile(function (sf) { return sf.getFilePath().endsWith(appEntryScript); })) {
-                            console.error("Cannot find entry script '".concat(appEntryScript, "'"));
+                        path = require("path");
+                        entryScriptPath = path.resolve(this.cwd, appEntryScript.replace(/^\//, ""));
+                        if (!fs_1.default.existsSync(entryScriptPath)) {
+                            console.error("Cannot find entry script '".concat(appEntryScript, "' at ").concat(entryScriptPath));
                             return [2 /*return*/, process.exit(1)];
                         }
-                        sf = this.createSourceFile(["start.ts"], "// Generated ".concat(new Date(), "\nimport \"./generatedHandlers").concat(this.isEsm ? ".js" : "", "\";\nimport \"./generatedRepos").concat(this.isEsm ? ".js" : "", "\";\nimport \"./generatedJobs").concat(this.isEsm ? ".js" : "", "\";\nimport \"..").concat(appEntryScript.replace(/\.ts/g, "")).concat(this.isEsm ? ".js" : "", "\";\nexport default {}; // Export an empty object to make it a module\n"));
-                        return [4 /*yield*/, sf.save()];
+                        if (!!this.project.getSourceFile(function (sf) { return sf.getFilePath().endsWith(appEntryScript); })) return [3 /*break*/, 3];
+                        this.project.addSourceFileAtPath(entryScriptPath);
+                        if (!appEntryScript.includes("/spec/")) return [3 /*break*/, 2];
+                        return [4 /*yield*/, (0, tiny_glob_1.default)((0, path_1.join)(this.cwd, "spec/**/*.ts"))];
                     case 1:
-                        _a.sent();
+                        specFiles = _a.sent();
+                        this.project.addSourceFilesAtPaths(specFiles);
+                        console.log("Added ".concat(specFiles.length, " spec files to compilation"));
+                        _a.label = 2;
+                    case 2:
+                        // Resolve any imports from the entry script
+                        this.resolveImportedFiles();
+                        _a.label = 3;
+                    case 3:
+                        extensionImports = this.compilerPlugins
+                            .map(function (ext) { return "import \"./".concat(ext.generatedFile).concat(_this.isEsm ? ".js" : "", "\";"); })
+                            .join("\n");
+                        sf = this.createSourceFile(["start.ts"], "// Generated ".concat(new Date(), "\nimport \"./generatedHandlers").concat(this.isEsm ? ".js" : "", "\";\nimport \"./generatedRepos").concat(this.isEsm ? ".js" : "", "\";\nimport \"./generatedTools").concat(this.isEsm ? ".js" : "", "\";\nimport \"./generatedAgents").concat(this.isEsm ? ".js" : "", "\";\nimport \"./generatedJobs").concat(this.isEsm ? ".js" : "", "\";\nimport \"./generatedServices").concat(this.isEsm ? ".js" : "", "\";\n").concat(extensionImports ? extensionImports + "\n" : "", "import \"..").concat(appEntryScript.replace(/\.ts/g, "")).concat(this.isEsm ? ".js" : "", "\";\nexport default {}; // Export an empty object to make it a module\n"));
+                        // Defer save until batch save at end (performance optimization)
                         return [2 /*return*/, sf];
                 }
             });
@@ -441,548 +1194,431 @@ var TypeScriptCompiler = /** @class */ (function () {
         });
     };
     /**
-     * Parses handlers `Handler<...>` function and its type arguments to extract
-     * which schemas to use.
-     *
-     * There are multiple ways of defining schema types as valid ts and this
-     * implementation aims to support all of these.
-     *
-     * Some examples of different cases (check spec/mock-project/src/handlers for more):
-     *
-     * ```
-     * // Interface reference
-     * Handler<Ctx, Car>
-     * // Inline type definition with reference to interface
-     * Handler<Ctx, {car: Car}>
-     * // Inline type definition with literal values
-     * Handler<Ctx, {car: {model: string}}>
-     * // Array
-     * Handler<Ctx, Car[]>
-     * // Array with inline type definition
-     * Handler<Ctx, {car: Car}[]>
-     * ```
-     *
-     * Return names of req and/or res schema types.
+     * Extracts schema information from a tool file using text-based parsing.
+     * Resolves type names to schema $ids from the schema universe.
      */
-    TypeScriptCompiler.prototype.extractSchemasFromHandlerSourceFile = function (handlerSourceFile) {
+    TypeScriptCompiler.prototype.extractSchemasFromToolFast = function (filePath) {
         return __awaiter(this, void 0, void 0, function () {
-            var defaultExport, handlerTypeRef;
+            var fileText, schemaDetection, typeArgs, baseName, inputTypeName, outputTypeName, inputSchemaType, outputSchemaType, inputTypeHint, outputTypeHint, baseName, unwrappedTypeName, baseName;
             return __generator(this, function (_a) {
-                defaultExport = (0, TypeScriptUtils_1.getDefaultExport)(handlerSourceFile);
-                if (defaultExport) {
-                    handlerTypeRef = defaultExport.getFirstDescendantByKindOrThrow(ts_morph_1.SyntaxKind.TypeReference);
-                    return [2 /*return*/, this.extractSchemaTypeFromHandler(handlerTypeRef)];
+                fileText = fs_1.default.readFileSync(filePath, "utf8");
+                schemaDetection = schema_extraction_1.TypeScriptSourceParser.detectSchemaType(fileText);
+                if (schemaDetection.shouldSkipTypeScriptExtraction) {
+                    return [2 /*return*/, {
+                            inputSchemaType: undefined,
+                            outputSchemaType: undefined,
+                        }];
+                }
+                typeArgs = schema_extraction_1.TypeScriptSourceParser.parseFlinkToolTypeArgs(fileText);
+                if (!typeArgs) {
+                    baseName = require("path").basename(filePath, require("path").extname(filePath));
+                    perfLog.trace("  Tool ".concat(baseName, ": Could not parse FlinkTool type arguments"));
+                    return [2 /*return*/, {
+                            inputSchemaType: undefined,
+                            outputSchemaType: undefined,
+                        }];
+                }
+                inputTypeName = typeArgs.inputType;
+                outputTypeName = typeArgs.outputType;
+                inputSchemaType = undefined;
+                outputSchemaType = undefined;
+                inputTypeHint = undefined;
+                outputTypeHint = undefined;
+                // Determine input type hint
+                if (inputTypeName.toLowerCase() === "void") {
+                    inputTypeHint = "void";
+                }
+                else if (inputTypeName.toLowerCase() === "any") {
+                    inputTypeHint = "any";
+                }
+                else if (schema_extraction_1.TypeScriptSourceParser.shouldGenerateSchema(inputTypeName)) {
+                    inputTypeHint = "named";
+                    inputSchemaType = this.resolveTypeNameToSchemaId(fileText, inputTypeName, filePath);
+                    if (!inputSchemaType) {
+                        baseName = require("path").basename(filePath);
+                        perfLog.warn("Tool ".concat(baseName, ": Could not resolve input type \"").concat(inputTypeName, "\" to schema $id. Make sure it's exported from src/schemas/"));
+                    }
+                }
+                unwrappedTypeName = schema_extraction_1.TypeScriptSourceParser.unwrapToolResultType(outputTypeName);
+                if (unwrappedTypeName.toLowerCase() === "void") {
+                    outputTypeHint = "void";
                 }
-                else {
-                    console.warn("Handler ".concat(handlerSourceFile.getBaseName(), " is missing default exported handler function"));
+                else if (unwrappedTypeName.toLowerCase() === "any") {
+                    outputTypeHint = "any";
                 }
-                return [2 /*return*/];
+                else if (schema_extraction_1.TypeScriptSourceParser.shouldGenerateSchema(unwrappedTypeName)) {
+                    outputTypeHint = "named";
+                    outputSchemaType = this.resolveTypeNameToSchemaId(fileText, unwrappedTypeName, filePath);
+                    if (!outputSchemaType) {
+                        baseName = require("path").basename(filePath);
+                        perfLog.warn("Tool ".concat(baseName, ": Could not resolve output type \"").concat(unwrappedTypeName, "\" to schema $id. Make sure it's exported from src/schemas/"));
+                    }
+                }
+                return [2 /*return*/, {
+                        inputSchemaType: inputSchemaType,
+                        outputSchemaType: outputSchemaType,
+                        inputTypeHint: inputTypeHint,
+                        outputTypeHint: outputTypeHint,
+                    }];
             });
         });
     };
     /**
-     * Recursively copies an interface and all its dependencies from the same file
+     * Extracts schema information from a handler file using text-based parsing.
+     * Resolves type names to schema $ids from the schema universe.
      */
-    TypeScriptCompiler.prototype.copyInterfaceWithDependencies = function (interfaceDecl, handlerFile) {
-        var _a, _b, _c;
-        var interfaceName = ((_a = interfaceDecl.getName) === null || _a === void 0 ? void 0 : _a.call(interfaceDecl)) || ((_b = interfaceDecl.getFirstChildByKind(ts_morph_1.SyntaxKind.Identifier)) === null || _b === void 0 ? void 0 : _b.getText());
-        if (!interfaceName)
-            return;
-        // Check if already copied
-        var existingInterface = this.parsedTsSchemas.find(function (s) { return s.includes("interface ".concat(interfaceName, " ")) || s.includes("type ".concat(interfaceName, " =")); });
-        if (existingInterface)
-            return;
-        // Copy the interface
-        this.parsedTsSchemas.push(interfaceDecl.getText());
-        // Find and recursively copy dependencies from the same file
-        // First, find direct type references in this interface
-        var typeRefIdentifiers = interfaceDecl
-            .getDescendantsOfKind(ts_morph_1.SyntaxKind.TypeReference)
-            .filter(function (typeRefNode) { return !!typeRefNode.getFirstChildIfKind(ts_morph_1.SyntaxKind.Identifier); })
-            .map(function (typeRefNode) { return typeRefNode.getFirstChildIfKindOrThrow(ts_morph_1.SyntaxKind.Identifier); });
-        for (var _i = 0, typeRefIdentifiers_1 = typeRefIdentifiers; _i < typeRefIdentifiers_1.length; _i++) {
-            var typeRefIdentifier = typeRefIdentifiers_1[_i];
-            var typeSymbol = typeRefIdentifier.getSymbol();
-            if (typeSymbol) {
-                var declaredType = typeSymbol.getDeclaredType();
-                var declaration = (_c = declaredType.getSymbol()) === null || _c === void 0 ? void 0 : _c.getDeclarations()[0];
-                if (declaration && declaration.getSourceFile() === handlerFile) {
-                    // Same file - recursively copy this dependency
-                    this.copyInterfaceWithDependencies(declaration, handlerFile);
-                }
-                else if (declaration && declaration.getSourceFile() !== handlerFile) {
-                    // Different file - add to imports
-                    var declaredTypeSymbol = declaredType.getSymbol();
-                    if (declaredTypeSymbol) {
-                        this.tsSchemasSymbolsToImports.push(declaredTypeSymbol);
-                    }
-                }
-            }
-        }
-    };
-    TypeScriptCompiler.prototype.saveIntermediateTsSchema = function (schema, handlerFile, suffix) {
+    TypeScriptCompiler.prototype.extractSchemasFromHandlerFast = function (filePath) {
         return __awaiter(this, void 0, void 0, function () {
-            var schemaText, handlerFileName, generatedSchemaInterfaceStr, schemaInterfaceName, schemaSymbol, interfaceName, declaration, _i, _a, typeToImport, typeSymbol, declaredTypeSymbol, _b, _c, prop, propDecl, propText, interfaceNameMatches, _d, interfaceNameMatches_1, match, referencedInterfaceName, referencedInterfaceDecl, arrayTypeArg, schemaSymbol, interfaceName, declaration, props, _e, _f, typeToImport, typeSymbol, declaredTypeSymbol, schemaSymbol, declarations, declaration, propertySignatures, _g, _h, prop, propType, typeSymbol, typeDeclaration, elementType, elementSymbol, elementDeclaration, currentPropTypeText, interfaceNameMatches, _j, interfaceNameMatches_2, match, interfaceName, interfaceDecl, typeArgs, _k, typeArgs_1, typeArg, argSymbol, argDeclaration, _l, _m, typeToImport, typeSymbol, declaredTypeSymbol;
-            return __generator(this, function (_o) {
-                if (schema.isAny()) {
-                    return [2 /*return*/]; // 'any' indicates that no schema is used
-                }
-                schemaText = schema.getText();
-                if (schemaText === 'void' || schemaText === 'undefined') {
-                    return [2 /*return*/];
-                }
-                handlerFileName = handlerFile.getBaseNameWithoutExtension().replace(/\./g, "_");
-                generatedSchemaInterfaceStr = "";
-                schemaInterfaceName = "".concat(handlerFileName, "_").concat(suffix);
-                if (schema.isInterface()) {
-                    schemaSymbol = schema.getSymbolOrThrow();
-                    interfaceName = (0, TypeScriptUtils_1.getInterfaceName)(schemaSymbol);
-                    declaration = schemaSymbol.getDeclarations()[0];
-                    if (declaration.getSourceFile() === handlerFile) {
-                        // Interface is declared within handler file
-                        generatedSchemaInterfaceStr = "export interface ".concat(schemaInterfaceName, " {\n          ").concat(schema
-                            .getProperties()
-                            .map(function (p) { return p.getValueDeclarationOrThrow().getText(); })
-                            .join("\n"), "\n        }");
-                        for (_i = 0, _a = (0, TypeScriptUtils_1.getTypesToImport)(declaration); _i < _a.length; _i++) {
-                            typeToImport = _a[_i];
-                            typeSymbol = typeToImport.getSymbol();
-                            if (typeSymbol) {
-                                declaredTypeSymbol = typeSymbol.getDeclaredType().getSymbol();
-                                if (declaredTypeSymbol) {
-                                    this.tsSchemasSymbolsToImports.push(declaredTypeSymbol);
-                                }
-                            }
-                        }
-                        // Also check for utility types with indexed access patterns like Partial<Foo["bar"]>
-                        for (_b = 0, _c = schema.getProperties(); _b < _c.length; _b++) {
-                            prop = _c[_b];
-                            propDecl = prop.getValueDeclaration();
-                            if (propDecl) {
-                                propText = propDecl.getText();
-                                interfaceNameMatches = propText.match(/\b([A-Z][a-zA-Z0-9]*)\s*\[/g);
-                                if (interfaceNameMatches) {
-                                    for (_d = 0, interfaceNameMatches_1 = interfaceNameMatches; _d < interfaceNameMatches_1.length; _d++) {
-                                        match = interfaceNameMatches_1[_d];
-                                        referencedInterfaceName = match.replace(/\s*\[$/, '').trim();
-                                        referencedInterfaceDecl = handlerFile.getInterface(referencedInterfaceName) || handlerFile.getTypeAlias(referencedInterfaceName);
-                                        if (referencedInterfaceDecl) {
-                                            // Interface is in same file - copy it and all its dependencies recursively
-                                            this.copyInterfaceWithDependencies(referencedInterfaceDecl, handlerFile);
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    else {
-                        // Interface is imported from other file
-                        generatedSchemaInterfaceStr = "export interface ".concat(schemaInterfaceName, " extends ").concat(interfaceName, " {}");
-                        this.tsSchemasSymbolsToImports.push(schemaSymbol);
-                    }
+            var fileText, typeArgs, baseName, reqTypeName, resTypeName, paramsTypeName, queryTypeName, reqSchemaType, resSchemaType, isSkipValidation, baseName, baseName, paramsMetadata, queryMetadata, metadata, metadata;
+            return __generator(this, function (_a) {
+                fileText = fs_1.default.readFileSync(filePath, "utf8");
+                typeArgs = schema_extraction_1.TypeScriptSourceParser.parseHandlerTypeArgs(fileText);
+                if (!typeArgs) {
+                    baseName = require("path").basename(filePath, require("path").extname(filePath));
+                    perfLog.trace("  Handler ".concat(baseName, ": Could not parse Handler type arguments"));
+                    return [2 /*return*/, {
+                            reqSchemaType: undefined,
+                            resSchemaType: undefined,
+                            queryMetadata: [],
+                            paramsMetadata: [],
+                        }];
                 }
-                else if (schema.isArray()) {
-                    arrayTypeArg = schema.getTypeArguments()[0];
-                    schemaSymbol = arrayTypeArg.getSymbolOrThrow();
-                    interfaceName = schemaSymbol.getEscapedName();
-                    declaration = schemaSymbol.getDeclarations()[0];
-                    if (declaration.getSourceFile() !== handlerFile) {
-                        generatedSchemaInterfaceStr = "export interface ".concat(schemaInterfaceName, " extends Array<").concat(interfaceName, "> {}");
-                        this.tsSchemasSymbolsToImports.push(schemaSymbol);
-                    }
-                    else {
-                        if (arrayTypeArg.isInterface()) {
-                            props = arrayTypeArg
-                                .getProperties()
-                                .map(function (p) { return p.getValueDeclarationOrThrow().getText(); })
-                                .join(" ");
-                            generatedSchemaInterfaceStr = "export interface ".concat(schemaInterfaceName, " extends Array<{").concat(props, "}> {}");
-                        }
-                        else {
-                            generatedSchemaInterfaceStr = "export interface ".concat(schemaInterfaceName, " extends Array<").concat(declaration.getText(), "> {}");
-                        }
-                        for (_e = 0, _f = (0, TypeScriptUtils_1.getTypesToImport)(declaration); _e < _f.length; _e++) {
-                            typeToImport = _f[_e];
-                            typeSymbol = typeToImport.getSymbol();
-                            if (typeSymbol) {
-                                declaredTypeSymbol = typeSymbol.getDeclaredType().getSymbol();
-                                if (declaredTypeSymbol) {
-                                    this.tsSchemasSymbolsToImports.push(declaredTypeSymbol);
-                                }
-                            }
-                        }
+                reqTypeName = typeArgs.reqType;
+                resTypeName = typeArgs.resType;
+                paramsTypeName = typeArgs.paramsType;
+                queryTypeName = typeArgs.queryType;
+                reqSchemaType = undefined;
+                resSchemaType = undefined;
+                isSkipValidation = /ValidationMode\.SkipValidation/.test(fileText);
+                if (reqTypeName && schema_extraction_1.TypeScriptSourceParser.shouldGenerateSchema(reqTypeName)) {
+                    reqSchemaType = this.resolveTypeNameToSchemaId(fileText, reqTypeName, filePath);
+                    if (!reqSchemaType && !isSkipValidation) {
+                        baseName = require("path").basename(filePath);
+                        perfLog.warn("Handler ".concat(baseName, ": Could not resolve request type \"").concat(reqTypeName, "\" to schema $id. Make sure it's exported from src/schemas/"));
                     }
                 }
-                else if (schema.isObject()) {
-                    schemaSymbol = schema.getSymbol();
-                    declarations = schemaSymbol === null || schemaSymbol === void 0 ? void 0 : schemaSymbol.getDeclarations();
-                    declaration = declarations === null || declarations === void 0 ? void 0 : declarations[0];
-                    propertySignatures = schema.getProperties().map(function (prop) {
-                        var propName = prop.getName();
-                        var propType = prop.getTypeAtLocation(handlerFile);
-                        var propTypeText = propType.getText(undefined, ts_morph_1.ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope);
-                        // Check if property is optional
-                        // For utility types (Omit, Pick, etc.), properties may not have value declarations
-                        var valueDeclaration = prop.getValueDeclaration();
-                        var isOptional = false;
-                        if (valueDeclaration) {
-                            // Property has a source declaration (normal case)
-                            isOptional = valueDeclaration.getType().isNullable() || valueDeclaration.compilerNode.questionToken !== undefined;
-                        }
-                        else {
-                            // Property is synthetic (from utility types like Omit, Pick, etc.)
-                            // Check if the property itself is optional by examining the symbol flags
-                            isOptional = !!(prop.getFlags() & ts_morph_1.ts.SymbolFlags.Optional);
-                        }
-                        return "".concat(propName).concat(isOptional ? "?" : "", ": ").concat(propTypeText);
-                    });
-                    // Extract type references for imports from resolved types
-                    for (_g = 0, _h = schema.getProperties(); _g < _h.length; _g++) {
-                        prop = _h[_g];
-                        propType = prop.getTypeAtLocation(handlerFile);
-                        typeSymbol = propType.getSymbol();
-                        if (typeSymbol) {
-                            typeDeclaration = typeSymbol.getDeclarations()[0];
-                            if (typeDeclaration && typeDeclaration.getSourceFile() !== handlerFile) {
-                                this.tsSchemasSymbolsToImports.push(typeSymbol);
-                            }
-                        }
-                        // Also check for array element types
-                        if (propType.isArray()) {
-                            elementType = propType.getArrayElementType();
-                            elementSymbol = elementType === null || elementType === void 0 ? void 0 : elementType.getSymbol();
-                            if (elementSymbol) {
-                                elementDeclaration = elementSymbol.getDeclarations()[0];
-                                if (elementDeclaration && elementDeclaration.getSourceFile() !== handlerFile) {
-                                    this.tsSchemasSymbolsToImports.push(elementSymbol);
-                                }
-                            }
-                        }
-                        currentPropTypeText = propType.getText(undefined, ts_morph_1.ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope);
-                        interfaceNameMatches = currentPropTypeText.match(/\b([A-Z][a-zA-Z0-9]*)\s*\[/g);
-                        if (interfaceNameMatches) {
-                            for (_j = 0, interfaceNameMatches_2 = interfaceNameMatches; _j < interfaceNameMatches_2.length; _j++) {
-                                match = interfaceNameMatches_2[_j];
-                                interfaceName = match.replace(/\s*\[$/, '').trim();
-                                interfaceDecl = handlerFile.getInterface(interfaceName) || handlerFile.getTypeAlias(interfaceName);
-                                if (interfaceDecl) {
-                                    // Interface is in same file - copy it and all its dependencies recursively
-                                    this.copyInterfaceWithDependencies(interfaceDecl, handlerFile);
-                                }
-                            }
-                        }
-                        typeArgs = propType.getTypeArguments();
-                        if (typeArgs && typeArgs.length > 0) {
-                            for (_k = 0, typeArgs_1 = typeArgs; _k < typeArgs_1.length; _k++) {
-                                typeArg = typeArgs_1[_k];
-                                argSymbol = typeArg.getSymbol();
-                                if (argSymbol) {
-                                    argDeclaration = argSymbol.getDeclarations()[0];
-                                    if (argDeclaration && argDeclaration.getSourceFile() !== handlerFile) {
-                                        this.tsSchemasSymbolsToImports.push(argSymbol);
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    // If we have a declaration, check if we need to import any types
-                    if (declaration) {
-                        for (_l = 0, _m = (0, TypeScriptUtils_1.getTypesToImport)(declaration); _l < _m.length; _l++) {
-                            typeToImport = _m[_l];
-                            typeSymbol = typeToImport.getSymbol();
-                            if (typeSymbol) {
-                                declaredTypeSymbol = typeSymbol.getDeclaredType().getSymbol();
-                                if (declaredTypeSymbol) {
-                                    this.tsSchemasSymbolsToImports.push(declaredTypeSymbol);
-                                }
-                            }
-                        }
+                if (resTypeName && schema_extraction_1.TypeScriptSourceParser.shouldGenerateSchema(resTypeName)) {
+                    resSchemaType = this.resolveTypeNameToSchemaId(fileText, resTypeName, filePath);
+                    if (!resSchemaType && !isSkipValidation) {
+                        baseName = require("path").basename(filePath);
+                        perfLog.warn("Handler ".concat(baseName, ": Could not resolve response type \"").concat(resTypeName, "\" to schema $id. Make sure it's exported from src/schemas/"));
                     }
-                    generatedSchemaInterfaceStr = "export interface ".concat(schemaInterfaceName, " { ").concat(propertySignatures.join(";\n"), " }");
                 }
-                else {
-                    console.log("[WARN] Unknown schema type", schema.getText());
+                paramsMetadata = [];
+                queryMetadata = [];
+                if (paramsTypeName && paramsTypeName !== "any" && paramsTypeName !== "void") {
+                    metadata = schema_extraction_1.TypeScriptSourceParser.extractPropertyMetadata(fileText, paramsTypeName);
+                    if (metadata) {
+                        paramsMetadata = metadata;
+                    }
                 }
-                if (generatedSchemaInterfaceStr) {
-                    this.parsedTsSchemas.push(generatedSchemaInterfaceStr);
-                    return [2 /*return*/, schemaInterfaceName];
+                if (queryTypeName && queryTypeName !== "any" && queryTypeName !== "void") {
+                    metadata = schema_extraction_1.TypeScriptSourceParser.extractPropertyMetadata(fileText, queryTypeName);
+                    if (metadata) {
+                        queryMetadata = metadata;
+                    }
                 }
-                return [2 /*return*/];
+                return [2 /*return*/, {
+                        reqSchemaType: reqSchemaType,
+                        resSchemaType: resSchemaType,
+                        queryMetadata: queryMetadata,
+                        paramsMetadata: paramsMetadata,
+                    }];
             });
         });
     };
-    TypeScriptCompiler.prototype.initJsonSchemaGenerator = function (schemaFilePath) {
-        var tsconfigPath = (0, path_1.join)(this.cwd, "tsconfig.json");
-        var conf = {
-            path: schemaFilePath, // Point to the intermediate schema file
-            expose: "none", // Do not create shared $ref definitions.
-            topRef: false, // Removes the wrapper object around the schema.
-            additionalProperties: false,
-            jsDoc: "basic",
-            sortProps: false,
-            strictTuples: false,
-            minify: false,
-            markdownDescription: false,
-            skipTypeCheck: false,
-            encodeRefs: false,
-            extraTags: [],
-            functions: "fail",
-            discriminatorType: "json-schema",
-            tsconfig: tsconfigPath,
-        };
-        console.log("Creating TypeScript program for schema generation:");
-        console.log("  Schema file:", schemaFilePath);
-        console.log("  tsconfig:", tsconfigPath);
-        // Create a fresh TypeScript Program that includes the schema file
-        // This ensures ts-json-schema-generator can find the types we just generated
-        var program;
-        try {
-            program = (0, ts_json_schema_generator_1.createProgram)(conf);
-        }
-        catch (error) {
-            // Format the error in a more developer-friendly way
-            console.error("\n❌ Schema generation failed due to TypeScript compilation errors:\n");
-            if (error.diagnostic && error.diagnostic.relatedInformation) {
-                // Extract and display only the relevant error messages
-                for (var _i = 0, _a = error.diagnostic.relatedInformation; _i < _a.length; _i++) {
-                    var info = _a[_i];
-                    if (info.file) {
-                        var _b = info.file.getLineAndCharacterOfPosition(info.start), line = _b.line, character = _b.character;
-                        var fileName = info.file.fileName.replace(this.cwd, ".");
-                        var message = typeof info.messageText === "string" ? info.messageText : info.messageText.messageText;
-                        console.error("  ".concat(fileName, ":").concat(line + 1, ":").concat(character + 1));
-                        console.error("  ".concat(message, "\n"));
-                    }
-                }
-            }
-            else if (error.message) {
-                console.error("  ".concat(error.message, "\n"));
-            }
-            console.error("💡 Tip: Fix the TypeScript errors above and try again.\n");
-            process.exit(1);
+    /**
+     * Check if handler source file is up for auto registration by inspecting
+     * the Route.
+     *
+     * @param sf handler file
+     * @returns
+     */
+    TypeScriptCompiler.prototype.isAutoRegisterableHandler = function (sf) {
+        var route = sf.getVariableDeclaration("Route");
+        if (!route) {
+            return false;
         }
-        console.log("  TypeScript version:", ts_morph_1.ts.version);
-        console.log("  Program root files:", program.getRootFileNames().length);
-        var formatter = (0, ts_json_schema_generator_1.createFormatter)(conf);
-        var parser = (0, ts_json_schema_generator_1.createParser)(program, conf);
-        var generator = new ts_json_schema_generator_1.SchemaGenerator(program, parser, formatter, conf);
-        return generator;
-    };
-    TypeScriptCompiler.prototype.generateAndSaveJsonSchemas = function (schemas, schemaFilePath) {
+        var routeProps = route.getFirstDescendantByKindOrThrow(ts_morph_1.SyntaxKind.ObjectLiteralExpression);
+        var skipAutoRegProp = routeProps.getProperty("skipAutoRegister");
+        return !skipAutoRegProp || skipAutoRegProp.getText().endsWith("false");
+    };
+    /**
+     * Generates JSON schemas for all handlers and tools.
+     * Should be called after parseHandlers() and parseTools() have completed.
+     *
+     * NEW SIMPLIFIED APPROACH:
+     * 1. Generate schema universe from src/schemas/**\/*.ts (includes wrappers/)
+     * 2. Handlers/tools reference schemas by $id
+     * 3. Create manifest with schema universe and references
+     */
+    TypeScriptCompiler.prototype.generateAllSchemas = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var jsonSchemas, _i, schemas_1, _a, reqSchemaType, resSchemaType, mergedSchemas, filePath;
-            var _b, _c;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
+            var schemaGenStartTime, path, schemaDir, schemaFiles, schemaUniverse, _i, schemaFiles_1, schemaFile, absolutePath, fileSchemas, schemaGenTime;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
                     case 0:
-                        // Reset schema generator to use the newly created intermediate schema file
-                        this.schemaGenerator = undefined;
-                        jsonSchemas = [];
-                        for (_i = 0, schemas_1 = schemas; _i < schemas_1.length; _i++) {
-                            _a = schemas_1[_i], reqSchemaType = _a.reqSchemaType, resSchemaType = _a.resSchemaType;
-                            if (reqSchemaType) {
-                                jsonSchemas.push({ definitions: (_b = {}, _b[reqSchemaType] = this.generateJsonSchema(reqSchemaType, schemaFilePath), _b) });
+                        schemaGenStartTime = Date.now();
+                        // Initialize schema generator
+                        return [4 /*yield*/, this.initSchemaGenerator()];
+                    case 1:
+                        // Initialize schema generator
+                        _a.sent();
+                        if (!this.schemaGenerator) {
+                            throw new Error("Schema generator not initialized");
+                        }
+                        path = require("path");
+                        schemaDir = path.join(this.cwd, "src/schemas");
+                        // Check if schemas directory exists
+                        if (!fs_1.default.existsSync(schemaDir)) {
+                            perfLog.warn("No src/schemas/ directory found. Skipping schema generation.");
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, (0, tiny_glob_1.default)(path.join(schemaDir, "**/*.ts"))];
+                    case 2:
+                        schemaFiles = _a.sent();
+                        perfLog.debug("Found ".concat(schemaFiles.length, " schema files in src/schemas/"));
+                        schemaUniverse = {};
+                        for (_i = 0, schemaFiles_1 = schemaFiles; _i < schemaFiles_1.length; _i++) {
+                            schemaFile = schemaFiles_1[_i];
+                            absolutePath = path.join(this.cwd, schemaFile);
+                            try {
+                                fileSchemas = this.schemaGenerator(absolutePath, {
+                                    followImports: "local",
+                                    schemaVersion: "http://json-schema.org/draft-07/schema#",
+                                    includeJSDoc: true,
+                                    strictObjects: false,
+                                    additionalProperties: undefined,
+                                    defineId: function (typeName, declaration, context) {
+                                        if (!context)
+                                            return typeName;
+                                        // Generate stable $id using same algorithm as resolveTypeNameToSchemaId
+                                        return _this.filePathToSchemaId(context.absolutePath, typeName);
+                                    },
+                                });
+                                // Merge schemas from this file into universe
+                                schemaUniverse = __assign(__assign({}, schemaUniverse), fileSchemas);
                             }
-                            if (resSchemaType) {
-                                jsonSchemas.push({ definitions: (_c = {}, _c[resSchemaType] = this.generateJsonSchema(resSchemaType, schemaFilePath), _c) });
+                            catch (error) {
+                                perfLog.warn("Failed to generate schemas from ".concat(schemaFile, ": ").concat(error.message));
                             }
                         }
-                        mergedSchemas = jsonSchemas.reduce(function (out, schema) {
-                            if (schema.definitions) {
-                                out.definitions = __assign(__assign({}, out.definitions), schema.definitions);
-                            }
-                            return out;
-                        }, {
-                            $schema: "http://json-schema.org/draft-07/schema#",
-                            $ref: "#/definitions/Schemas",
-                            definitions: {},
-                        });
-                        filePath = (0, path_1.join)(this.cwd, ".flink", "schemas", "schemas.json");
-                        return [4 /*yield*/, (0, FsUtils_1.writeJsonFile)(filePath, mergedSchemas)];
-                    case 1:
-                        _d.sent();
-                        this.project.addSourceFileAtPath(filePath);
-                        return [2 /*return*/, mergedSchemas];
+                        perfLog.debug("Generated ".concat(Object.keys(schemaUniverse).length, " schemas from ").concat(schemaFiles.length, " files"));
+                        perfLog.debug("Sample schema $ids: ".concat(Object.keys(schemaUniverse).slice(0, 10).join(", "), "..."));
+                        // Create manifest with schema universe and handler/tool references
+                        return [4 /*yield*/, this.generateSchemaManifest(schemaUniverse)];
+                    case 3:
+                        // Create manifest with schema universe and handler/tool references
+                        _a.sent();
+                        schemaGenTime = Date.now() - schemaGenStartTime;
+                        initLog.info("\u2713 Schema generation completed in ".concat(schemaGenTime, "ms ") +
+                            "(".concat(Object.keys(schemaUniverse).length, " schemas, ").concat(this.handlerSchemasToGenerate.length, " handlers, ").concat(this.toolSchemasToGenerate.length, " tools)"));
+                        return [2 /*return*/];
                 }
             });
         });
     };
-    TypeScriptCompiler.prototype.generateJsonSchema = function (typeName, schemaFilePath) {
-        if (!this.schemaGenerator) {
-            this.schemaGenerator = this.initJsonSchemaGenerator(schemaFilePath);
-        }
-        return this.schemaGenerator.createSchema(typeName);
+    /**
+     * Computes relative path from project root for a source file.
+     * This is used consistently for manifest keys and __file exports.
+     */
+    TypeScriptCompiler.prototype.getRelativePath = function (sf) {
+        var filePath = sf.getFilePath();
+        return filePath.startsWith(this.cwd) ? filePath.substring(this.cwd.length + 1) : filePath;
     };
-    TypeScriptCompiler.prototype.extractSchemaTypeFromHandler = function (handlerTypeReference) {
+    /**
+     * Generates schema manifest with schema universe and handler/tool references.
+     */
+    TypeScriptCompiler.prototype.generateSchemaManifest = function (schemaUniverse) {
         return __awaiter(this, void 0, void 0, function () {
-            var handlerType, handlerTypeArgs, reqSchema, resSchema, params, query, sf, createReqSchemaPromise, createResSchemaPromise, _a, reqSchemaType, resSchemaType;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
+            var manifest, _i, _a, handler, relativePath, _b, _c, tool, relativePath, manifestPath;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
                     case 0:
-                        handlerType = handlerTypeReference.getTypeName().getText();
-                        handlerTypeArgs = handlerTypeReference.getType().getAliasTypeArguments();
-                        if (handlerType === "Handler") {
-                            // `Handler<Ctx, ReqSchema, ResSchema, Params, Query>`
-                            // 0 = Ctx, 1 = Req schema, 2 = Res schema, 3 = Params, 4 = Query
-                            reqSchema = handlerTypeArgs[1];
-                            resSchema = handlerTypeArgs[2];
-                            params = handlerTypeArgs[3];
-                            query = handlerTypeArgs[4];
-                        }
-                        else if (handlerType === "GetHandler") {
-                            // `GetHandler<Ctx, ResSchema, Params, Query>`
-                            // 0 = Ctx, 1 = Res schema, 2 = Params, 3 = Query
-                            resSchema = handlerTypeArgs[1];
-                            params = handlerTypeArgs[2];
-                            query = handlerTypeArgs[3];
+                        manifest = {
+                            version: "2.0",
+                            generated: new Date().toISOString(),
+                            schemas: schemaUniverse,
+                            handlers: {},
+                            tools: {},
+                        };
+                        // Map handlers with their schema references
+                        for (_i = 0, _a = this.handlerSchemasToGenerate; _i < _a.length; _i++) {
+                            handler = _a[_i];
+                            relativePath = this.getRelativePath(handler.sourceFile);
+                            // Validate schema references exist
+                            if (handler.reqSchemaType && !schemaUniverse[handler.reqSchemaType]) {
+                                perfLog.warn("Handler ".concat(handler.sourceFile.getBaseName(), " references request schema \"").concat(handler.reqSchemaType, "\" which was not found in schema universe"));
+                            }
+                            if (handler.resSchemaType && !schemaUniverse[handler.resSchemaType]) {
+                                perfLog.warn("Handler ".concat(handler.sourceFile.getBaseName(), " references response schema \"").concat(handler.resSchemaType, "\" which was not found in schema universe"));
+                            }
+                            manifest.handlers[relativePath] = {
+                                reqSchemaName: handler.reqSchemaType,
+                                resSchemaName: handler.resSchemaType,
+                                queryMetadata: handler.queryMetadata || [],
+                                paramsMetadata: handler.paramsMetadata || [],
+                            };
                         }
-                        else {
-                            throw new Error("Unknown handler type ".concat(handlerType, " in ").concat(handlerTypeReference.getSourceFile().getBaseName(), " - should be Handler or GetHandler"));
+                        // Map tools with their schema references
+                        for (_b = 0, _c = this.toolSchemasToGenerate; _b < _c.length; _b++) {
+                            tool = _c[_b];
+                            relativePath = this.getRelativePath(tool.sourceFile);
+                            // Validate schema references exist
+                            if (tool.inputSchemaType && !schemaUniverse[tool.inputSchemaType]) {
+                                perfLog.warn("Tool ".concat(tool.sourceFile.getBaseName(), " references input schema \"").concat(tool.inputSchemaType, "\" which was not found in schema universe"));
+                            }
+                            if (tool.outputSchemaType && !schemaUniverse[tool.outputSchemaType]) {
+                                perfLog.warn("Tool ".concat(tool.sourceFile.getBaseName(), " references output schema \"").concat(tool.outputSchemaType, "\" which was not found in schema universe"));
+                            }
+                            manifest.tools[relativePath] = {
+                                inputSchemaName: tool.inputSchemaType,
+                                outputSchemaName: tool.outputSchemaType,
+                                inputTypeHint: tool.inputTypeHint,
+                                outputTypeHint: tool.outputTypeHint,
+                            };
                         }
-                        sf = handlerTypeReference.getSourceFile();
-                        createReqSchemaPromise = reqSchema
-                            ? this.saveIntermediateTsSchema(reqSchema, sf, "".concat(handlerTypeReference.getStartLineNumber(), "_ReqSchema"))
-                            : Promise.resolve("");
-                        createResSchemaPromise = resSchema
-                            ? this.saveIntermediateTsSchema(resSchema, sf, "".concat(handlerTypeReference.getStartLineNumber(), "_ResSchema"))
-                            : Promise.resolve("");
-                        return [4 /*yield*/, Promise.all([createReqSchemaPromise, createResSchemaPromise])];
+                        manifestPath = (0, path_1.join)(this.cwd, "dist/.flink/schema-manifest.json");
+                        return [4 /*yield*/, (0, FsUtils_1.writeJsonFile)(manifestPath, manifest, { ensureDir: true })];
                     case 1:
-                        _a = _b.sent(), reqSchemaType = _a[0], resSchemaType = _a[1];
-                        return [2 /*return*/, {
-                                reqSchemaType: reqSchemaType,
-                                resSchemaType: resSchemaType,
-                                queryMetadata: (0, TypeScriptUtils_1.getTypeMetadata)(query),
-                                paramsMetadata: (0, TypeScriptUtils_1.getTypeMetadata)(params),
-                            }];
+                        _d.sent();
+                        perfLog.debug("Schema manifest written to: ".concat(manifestPath));
+                        return [2 /*return*/];
                 }
             });
         });
     };
     /**
-     * Creates generated source file that contains all
-     * TypeScript schemas that has been derived from handlers.
+     * Scans project for jobs so they can be registered during start.
      */
-    TypeScriptCompiler.prototype.createIntermediateSchemaFile = function () {
+    TypeScriptCompiler.prototype.parseJobs = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var schemaSourceFile;
+            var startTime, generatedFile, jobsArr, imports, jobElements, jobParseTime;
+            var _this = this;
             return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        schemaSourceFile = this.createSourceFile(["schemas", "schemas.ts"], "// Generated ".concat(new Date(), "\n").concat(this.parsedTsSchemas.join("\n\n")));
-                        (0, TypeScriptUtils_1.addImports)(schemaSourceFile, this.tsSchemasSymbolsToImports);
-                        return [4 /*yield*/, schemaSourceFile.save()];
-                    case 1:
-                        _a.sent();
-                        // Return the file path so it can be used by ts-json-schema-generator
-                        return [2 /*return*/, schemaSourceFile.getFilePath()];
-                }
+                startTime = Date.now();
+                generatedFile = this.createSourceFile(["generatedJobs.ts"], "// Generated ".concat(new Date(), "\nimport { autoRegisteredJobs } from \"@flink-app/flink\";\nexport const jobs = [];\nautoRegisteredJobs.push(...jobs);\n    "));
+                jobsArr = generatedFile.getVariableDeclarationOrThrow("jobs").getFirstDescendantByKindOrThrow(ts_morph_1.SyntaxKind.ArrayLiteralExpression);
+                imports = [];
+                jobElements = [];
+                // Use pre-segmented job files (no filtering needed)
+                this.jobFiles.forEach(function (sf, i) {
+                    console.log("Detected job ".concat(sf.getBaseName()));
+                    var namespaceImport = sf.getBaseNameWithoutExtension().replace(/\./g, "_") + "_" + i;
+                    imports.push({
+                        defaultImport: "* as " + namespaceImport,
+                        moduleSpecifier: _this.getModuleSpecifier(generatedFile, sf),
+                    });
+                    // __file is set on the registration object (not injected into source files)
+                    jobElements.push("{...".concat(namespaceImport, ", __file: \"").concat(_this.getRelativePath(sf), "\"}"));
+                });
+                // Add all job elements in one batch operation
+                jobsArr.addElements(jobElements);
+                generatedFile.addImportDeclarations(imports);
+                // Defer save until batch save at end (performance optimization)
+                // Cleanup: forget job file nodes to reduce memory overhead (ts-morph performance optimization)
+                this.jobFiles.forEach(function (sf) {
+                    sf.getClasses().forEach(function (cls) { return cls.forget(); });
+                });
+                jobParseTime = Date.now() - startTime;
+                perfLog.info("\u2713 Job parsing completed in ".concat(jobParseTime, "ms (").concat(jobElements.length, " jobs)"));
+                return [2 /*return*/, generatedFile];
             });
         });
     };
     /**
-     * Check if handler source file is up for auto registration by inspecting
-     * the Route.
-     *
-     * @param sf handler file
-     * @returns
+     * Scans project for services so they can be registered during start.
      */
-    TypeScriptCompiler.prototype.isAutoRegisterableHandler = function (sf) {
-        var route = sf.getVariableDeclaration("Route");
-        if (!route) {
-            return false;
-        }
-        var routeProps = route.getFirstDescendantByKindOrThrow(ts_morph_1.SyntaxKind.ObjectLiteralExpression);
-        var skipAutoRegProp = routeProps.getProperty("skipAutoRegister");
-        return !skipAutoRegProp || skipAutoRegProp.getText().endsWith("false");
+    TypeScriptCompiler.prototype.parseServices = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var startTime, generatedFile, servicesArr, imports, serviceElements, _i, _a, sf, serviceParseTime;
+            return __generator(this, function (_b) {
+                if (this.disableServices) {
+                    initLog.info("Services disabled via flink.config.js (disableServices: true)");
+                }
+                startTime = Date.now();
+                generatedFile = this.createSourceFile(["generatedServices.ts"], "// Generated ".concat(new Date(), "\nimport { autoRegisteredServices } from \"@flink-app/flink\";\nexport const services: any[] = [];\nautoRegisteredServices.push(...services);\n    "));
+                servicesArr = generatedFile.getVariableDeclarationOrThrow("services").getFirstDescendantByKindOrThrow(ts_morph_1.SyntaxKind.ArrayLiteralExpression);
+                imports = [];
+                serviceElements = [];
+                for (_i = 0, _a = this.serviceFiles; _i < _a.length; _i++) {
+                    sf = _a[_i];
+                    console.log("Detected service ".concat(sf.getBaseName()));
+                    imports.push({
+                        defaultImport: sf.getBaseNameWithoutExtension(),
+                        moduleSpecifier: this.getModuleSpecifier(generatedFile, sf),
+                    });
+                    serviceElements.push("{serviceInstanceName: \"".concat((0, utils_1.getRepoInstanceName)(sf.getBaseName()), "\", Service: ").concat(sf.getBaseNameWithoutExtension(), "}"));
+                }
+                servicesArr.addElements(serviceElements);
+                generatedFile.addImportDeclarations(imports);
+                // Cleanup: forget service file nodes to reduce memory overhead
+                this.serviceFiles.forEach(function (sf) {
+                    sf.getClasses().forEach(function (cls) { return cls.forget(); });
+                });
+                serviceParseTime = Date.now() - startTime;
+                perfLog.info("\u2713 Service parsing completed in ".concat(serviceParseTime, "ms (").concat(serviceElements.length, " services)"));
+                return [2 /*return*/, generatedFile];
+            });
+        });
     };
     /**
-     * Appends generated json schemas to handler source files.
-     *
-     * @param handlers
-     * @param jsonSchemas
+     * Generates a .flink/generatedXxx.ts file for a single compiler plugin extension.
+     * Mirrors the same namespace-import + spread pattern used by parseJobs.
      */
-    TypeScriptCompiler.prototype.appendSchemasToHandlerSourceFiles = function (handlers, jsonSchemas) {
-        var jsonSchemaDefs = jsonSchemas.definitions || {};
-        for (var _i = 0, handlers_1 = handlers; _i < handlers_1.length; _i++) {
-            var _a = handlers_1[_i], sourceFile = _a.sourceFile, reqSchemaType = _a.reqSchemaType, resSchemaType = _a.resSchemaType;
-            if (reqSchemaType && !jsonSchemaDefs[reqSchemaType]) {
-                console.error("Handler ".concat(sourceFile.getBaseName(), " has request schema\u00A0(").concat(reqSchemaType, ") defined, but no JSON schema has been generated"));
-                continue;
-            }
-            if (resSchemaType && !jsonSchemaDefs[resSchemaType]) {
-                console.error("Handler ".concat(sourceFile.getBaseName(), " has response schema\u00A0(").concat(resSchemaType, ") defined, but no JSON schema has been generated"));
-                continue;
-            }
-            var reqJsonSchema = JSON.stringify(reqSchemaType ? jsonSchemaDefs[reqSchemaType] : undefined);
-            var resJsonSchema = JSON.stringify(resSchemaType ? jsonSchemaDefs[resSchemaType] : undefined);
-            // Remove existing __schemas variable if it exists (to avoid redeclaration errors)
-            var existingSchemas = sourceFile.getVariableStatements().filter(function (vs) {
-                var varNames = vs.getDeclarations().map(function (d) { return d.getName(); });
-                return varNames.includes("__schemas");
-            });
-            existingSchemas.forEach(function (v) { return v.remove(); });
-            sourceFile.addVariableStatement({
-                declarationKind: ts_morph_1.VariableDeclarationKind.Const,
-                isExported: true,
-                declarations: [
-                    {
-                        name: "__schemas",
-                        type: "any",
-                        initializer: "{ reqSchema: ".concat(reqJsonSchema, ", resSchema: ").concat(resJsonSchema, " }"),
-                    },
-                ],
+    TypeScriptCompiler.prototype.parseExtensionDir = function (ext) {
+        return __awaiter(this, void 0, void 0, function () {
+            var startTime, files, generatedFile, itemsArr, imports, itemElements, elapsed;
+            var _this = this;
+            var _a;
+            return __generator(this, function (_b) {
+                startTime = Date.now();
+                files = (_a = this.extensionFiles.get(ext.generatedFile)) !== null && _a !== void 0 ? _a : [];
+                generatedFile = this.createSourceFile(["".concat(ext.generatedFile, ".ts")], "// Generated ".concat(new Date(), "\nimport { ").concat(ext.registrationVar, " } from \"").concat(ext.package, "\";\nexport const items: any[] = [];\n").concat(ext.registrationVar, ".push(...items);\n"));
+                itemsArr = generatedFile.getVariableDeclarationOrThrow("items").getFirstDescendantByKindOrThrow(ts_morph_1.SyntaxKind.ArrayLiteralExpression);
+                imports = [];
+                itemElements = [];
+                files.forEach(function (sf, i) {
+                    var namespaceImport = sf.getBaseNameWithoutExtension().replace(/\./g, "_") + "_" + i;
+                    imports.push({
+                        defaultImport: "* as " + namespaceImport,
+                        moduleSpecifier: _this.getModuleSpecifier(generatedFile, sf),
+                    });
+                    itemElements.push("{...".concat(namespaceImport, ", __file: \"").concat(_this.getRelativePath(sf), "\"}"));
+                });
+                itemsArr.addElements(itemElements);
+                generatedFile.addImportDeclarations(imports);
+                elapsed = Date.now() - startTime;
+                initLog.info("\u2713 Extension dir \"".concat(ext.scanDir, "\" parsed in ").concat(elapsed, "ms (").concat(files.length, " files)"));
+                return [2 /*return*/, generatedFile];
             });
-        }
+        });
     };
     /**
-     * Scans project for jobs so they can be registered during start.
+     * Iterates all compilerPlugins from flink.config.js and generates
+     * a .flink/generatedXxx.ts file for each one.
+     * Call this after parseJobs() and before generateStartScript().
      */
-    TypeScriptCompiler.prototype.parseJobs = function () {
+    TypeScriptCompiler.prototype.parseAllExtensionDirs = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var generatedFile, jobsArr, imports, i, _i, _a, sf, namespaceImport, existingFile;
+            var _i, _a, ext;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
-                        generatedFile = this.createSourceFile(["generatedJobs.ts"], "// Generated ".concat(new Date(), "\nimport { autoRegisteredJobs } from \"@flink-app/flink\";\nexport const jobs = [];\nautoRegisteredJobs.push(...jobs);\n    "));
-                        jobsArr = generatedFile.getVariableDeclarationOrThrow("jobs").getFirstDescendantByKindOrThrow(ts_morph_1.SyntaxKind.ArrayLiteralExpression);
-                        imports = [];
-                        i = 0;
-                        for (_i = 0, _a = this.project.getSourceFiles(); _i < _a.length; _i++) {
-                            sf = _a[_i];
-                            if (!sf.getFilePath().includes("src/jobs/")) {
-                                continue;
-                            }
-                            console.log("Detected job ".concat(sf.getBaseName()));
-                            namespaceImport = sf.getBaseNameWithoutExtension().replace(/\./g, "_") + "_" + i;
-                            imports.push({
-                                defaultImport: "* as " + namespaceImport,
-                                moduleSpecifier: this.getModuleSpecifier(generatedFile, sf),
-                            });
-                            existingFile = sf.getVariableStatements().filter(function (vs) {
-                                var varNames = vs.getDeclarations().map(function (d) { return d.getName(); });
-                                return varNames.includes("__file");
-                            });
-                            existingFile.forEach(function (v) { return v.remove(); });
-                            // Append metadata to source file that will be part of emitted dist bundle (javascript)
-                            sf.addVariableStatement({
-                                declarationKind: ts_morph_1.VariableDeclarationKind.Const,
-                                isExported: true,
-                                declarations: [
-                                    {
-                                        name: "__file",
-                                        initializer: "\"".concat(sf.getBaseName(), "\""),
-                                    },
-                                ],
-                            });
-                            jobsArr.insertElement(i, namespaceImport);
-                            i++;
-                        }
-                        generatedFile.addImportDeclarations(imports);
-                        return [4 /*yield*/, generatedFile.save()];
+                        _i = 0, _a = this.compilerPlugins;
+                        _b.label = 1;
                     case 1:
+                        if (!(_i < _a.length)) return [3 /*break*/, 4];
+                        ext = _a[_i];
+                        return [4 /*yield*/, this.parseExtensionDir(ext)];
+                    case 2:
                         _b.sent();
-                        return [2 /*return*/, generatedFile];
+                        _b.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/];
                 }
             });
         });