@warlock.js/core 4.0.174 → 4.1.3

package/esm/dev-server/health-checker/workers/eslint-health.worker.mjs

@@ -0,0 +1,188 @@
+import path from "path";
+import fs from "fs";
+import { ESLint } from "eslint";
+import { parentPort, workerData } from "worker_threads";
+
+//#region ../../@warlock.js/core/src/dev-server/health-checker/workers/eslint-health.worker.ts
+/**
+* ESLint Health Check Worker
+*
+* This worker runs in a dedicated thread to perform ESLint linting
+* without blocking the main dev server thread. It maintains a persistent
+* ESLint instance for efficient linting.
+*
+* Communication:
+* - Receives: { type: 'init' | 'check' | 'shutdown', ... }
+* - Sends: { type: 'results' | 'initialized' | 'error', ... }
+*/
+/**
+* ESLint Health Worker class
+* Maintains persistent ESLint instance for efficient linting
+*/
+var ESLintHealthWorker = class {
+	constructor() {
+		this.eslint = null;
+		this.initialized = false;
+		this.hasConfig = false;
+		this.cwd = process.cwd();
+	}
+	/**
+	* Initialize the worker with ESLint configuration
+	*/
+	initialize(config) {
+		try {
+			this.cwd = config.cwd || process.cwd();
+			const flatConfigPath = path.join(this.cwd, "eslint.config.js");
+			const flatConfigMjsPath = path.join(this.cwd, "eslint.config.mjs");
+			const flatConfigCjsPath = path.join(this.cwd, "eslint.config.cjs");
+			this.hasConfig = fs.existsSync(flatConfigPath) || fs.existsSync(flatConfigMjsPath) || fs.existsSync(flatConfigCjsPath);
+			if (!this.hasConfig) {
+				this.initialized = true;
+				return {
+					success: true,
+					hasConfig: false
+				};
+			}
+			this.eslint = new ESLint({ cwd: this.cwd });
+			this.initialized = true;
+			return {
+				success: true,
+				hasConfig: true
+			};
+		} catch (error) {
+			console.error("ESLint Worker: Failed to initialize:", error);
+			this.initialized = true;
+			return {
+				success: false,
+				hasConfig: false
+			};
+		}
+	}
+	/**
+	* Check files for ESLint errors
+	*/
+	async checkFiles(files) {
+		if (!this.eslint || !this.hasConfig) return files.map((file) => ({
+			path: file.path,
+			relativePath: file.relativePath,
+			healthy: true,
+			errors: [],
+			warnings: []
+		}));
+		const results = [];
+		for (const file of files) {
+			if (!this.isLintableFile(file.path)) {
+				results.push({
+					path: file.path,
+					relativePath: file.relativePath,
+					healthy: true,
+					errors: [],
+					warnings: []
+				});
+				continue;
+			}
+			try {
+				const result = await this.checkSingleFile(file);
+				results.push(result);
+			} catch (error) {
+				results.push({
+					path: file.path,
+					relativePath: file.relativePath,
+					healthy: true,
+					errors: [],
+					warnings: []
+				});
+			}
+		}
+		return results;
+	}
+	/**
+	* Check a single file for lint issues
+	*/
+	async checkSingleFile(file) {
+		if (!this.eslint) return {
+			path: file.path,
+			relativePath: file.relativePath,
+			healthy: true,
+			errors: [],
+			warnings: []
+		};
+		const lintResults = await this.eslint.lintText(file.content, { filePath: file.path });
+		if (lintResults.length === 0) return {
+			path: file.path,
+			relativePath: file.relativePath,
+			healthy: true,
+			errors: [],
+			warnings: []
+		};
+		const lintResult = lintResults[0];
+		const errors = [];
+		const warnings = [];
+		for (const message of lintResult.messages) {
+			const lintMessage = {
+				type: message.severity === 2 ? "error" : "warning",
+				message: message.message,
+				lineNumber: message.line || 1,
+				columnNumber: message.column || 1,
+				length: message.endColumn && message.column ? message.endColumn - message.column : 1,
+				filePath: file.path,
+				relativePath: file.relativePath,
+				ruleId: message.ruleId || void 0
+			};
+			if (message.severity === 2) errors.push(lintMessage);
+			else if (message.severity === 1) warnings.push(lintMessage);
+		}
+		return {
+			path: file.path,
+			relativePath: file.relativePath,
+			healthy: errors.length === 0 && warnings.length === 0,
+			errors,
+			warnings
+		};
+	}
+	/**
+	* Check if file is a lintable file
+	*/
+	isLintableFile(filePath) {
+		const ext = filePath.toLowerCase();
+		return ext.endsWith(".ts") || ext.endsWith(".tsx") || ext.endsWith(".js") || ext.endsWith(".jsx");
+	}
+};
+const worker = new ESLintHealthWorker();
+parentPort?.on("message", async (message) => {
+	try {
+		switch (message.type) {
+			case "init": {
+				const initResult = worker.initialize(message.config);
+				const response = {
+					type: "initialized",
+					success: initResult.success,
+					hasConfig: initResult.hasConfig
+				};
+				parentPort?.postMessage(response);
+				break;
+			}
+			case "check": {
+				const response = {
+					type: "results",
+					results: await worker.checkFiles(message.files)
+				};
+				parentPort?.postMessage(response);
+				break;
+			}
+			case "filesDeleted": break;
+			case "shutdown": process.exit(0);
+		}
+	} catch (error) {
+		const response = {
+			type: "error",
+			message: error instanceof Error ? error.message : String(error)
+		};
+		parentPort?.postMessage(response);
+	}
+});
+if (workerData?.autoInit) worker.initialize({ cwd: workerData.cwd || process.cwd() });
+
+//#endregion
+export {  };
+//# sourceMappingURL=eslint-health.worker.mjs.map

package/esm/dev-server/health-checker/workers/eslint-health.worker.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"eslint-health.worker.mjs","names":[],"sources":["../../../../../../../../@warlock.js/core/src/dev-server/health-checker/workers/eslint-health.worker.ts"],"sourcesContent":["/**\n * ESLint Health Check Worker\n *\n * This worker runs in a dedicated thread to perform ESLint linting\n * without blocking the main dev server thread. It maintains a persistent\n * ESLint instance for efficient linting.\n *\n * Communication:\n * - Receives: { type: 'init' | 'check' | 'shutdown', ... }\n * - Sends: { type: 'results' | 'initialized' | 'error', ... }\n */\nimport { ESLint } from \"eslint\";\nimport fs from \"fs\";\nimport path from \"path\";\nimport { parentPort, workerData } from \"worker_threads\";\n\n/**\n * Serialized file data received from main thread\n */\ntype SerializedFile = {\n  /** Absolute file path */\n  path: string;\n  /** File content (source code) */\n  content: string;\n  /** Relative path for display */\n  relativePath: string;\n};\n\n/**\n * Lint message sent back to main thread\n */\ntype LintMessage = {\n  type: \"error\" | \"warning\";\n  message: string;\n  lineNumber: number;\n  columnNumber: number;\n  length: number;\n  filePath: string;\n  relativePath: string;\n  ruleId?: string;\n};\n\n/**\n * Health check result for a single file\n */\ntype FileCheckResult = {\n  path: string;\n  relativePath: string;\n  healthy: boolean;\n  errors: LintMessage[];\n  warnings: LintMessage[];\n};\n\n/**\n * Messages received from main thread\n */\n/**\n * Deleted file info\n */\ntype DeletedFile = {\n  path: string;\n  relativePath: string;\n};\n\n/**\n * Messages received from main thread\n */\ntype WorkerMessage =\n  | { type: \"init\"; config: { cwd: string } }\n  | { type: \"check\"; files: SerializedFile[] }\n  | { type: \"filesDeleted\"; files: DeletedFile[] }\n  | { type: \"shutdown\" };\n\n/**\n * Messages sent to main thread\n */\ntype WorkerResponse =\n  | { type: \"initialized\"; success: boolean; hasConfig: boolean; error?: string }\n  | { type: \"results\"; results: FileCheckResult[] }\n  | { type: \"error\"; message: string };\n\n/**\n * ESLint Health Worker class\n * Maintains persistent ESLint instance for efficient linting\n */\nclass ESLintHealthWorker {\n  /**\n   * ESLint instance\n   */\n  private eslint: ESLint | null = null;\n\n  /**\n   * Whether the worker is initialized\n   */\n  private initialized = false;\n\n  /**\n   * Whether ESLint config was found\n   */\n  private hasConfig = false;\n\n  /**\n   * Current working directory\n   */\n  private cwd: string = process.cwd();\n\n  /**\n   * Initialize the worker with ESLint configuration\n   */\n  public initialize(config: { cwd: string }): { success: boolean; hasConfig: boolean } {\n    try {\n      this.cwd = config.cwd || process.cwd();\n\n      // Check if ESLint flat config exists\n      const flatConfigPath = path.join(this.cwd, \"eslint.config.js\");\n      const flatConfigMjsPath = path.join(this.cwd, \"eslint.config.mjs\");\n      const flatConfigCjsPath = path.join(this.cwd, \"eslint.config.cjs\");\n\n      this.hasConfig =\n        fs.existsSync(flatConfigPath) ||\n        fs.existsSync(flatConfigMjsPath) ||\n        fs.existsSync(flatConfigCjsPath);\n\n      if (!this.hasConfig) {\n        this.initialized = true;\n        return { success: true, hasConfig: false };\n      }\n\n      // Create ESLint instance with flat config\n      this.eslint = new ESLint({\n        cwd: this.cwd,\n      });\n\n      this.initialized = true;\n      return { success: true, hasConfig: true };\n    } catch (error) {\n      console.error(\"ESLint Worker: Failed to initialize:\", error);\n      this.initialized = true;\n      return { success: false, hasConfig: false };\n    }\n  }\n\n  /**\n   * Check files for ESLint errors\n   */\n  public async checkFiles(files: SerializedFile[]): Promise<FileCheckResult[]> {\n    if (!this.eslint || !this.hasConfig) {\n      // No ESLint config, return all files as healthy\n      return files.map((file) => ({\n        path: file.path,\n        relativePath: file.relativePath,\n        healthy: true,\n        errors: [],\n        warnings: [],\n      }));\n    }\n\n    const results: FileCheckResult[] = [];\n\n    for (const file of files) {\n      // Only lint lintable files\n      if (!this.isLintableFile(file.path)) {\n        results.push({\n          path: file.path,\n          relativePath: file.relativePath,\n          healthy: true,\n          errors: [],\n          warnings: [],\n        });\n        continue;\n      }\n\n      try {\n        const result = await this.checkSingleFile(file);\n        results.push(result);\n      } catch (error) {\n        // On error, mark as healthy to avoid blocking\n        results.push({\n          path: file.path,\n          relativePath: file.relativePath,\n          healthy: true,\n          errors: [],\n          warnings: [],\n        });\n      }\n    }\n\n    return results;\n  }\n\n  /**\n   * Check a single file for lint issues\n   */\n  private async checkSingleFile(file: SerializedFile): Promise<FileCheckResult> {\n    if (!this.eslint) {\n      return {\n        path: file.path,\n        relativePath: file.relativePath,\n        healthy: true,\n        errors: [],\n        warnings: [],\n      };\n    }\n\n    // Use lintText to lint from memory (not disk)\n    const lintResults = await this.eslint.lintText(file.content, {\n      filePath: file.path,\n    });\n\n    if (lintResults.length === 0) {\n      return {\n        path: file.path,\n        relativePath: file.relativePath,\n        healthy: true,\n        errors: [],\n        warnings: [],\n      };\n    }\n\n    const lintResult = lintResults[0];\n    const errors: LintMessage[] = [];\n    const warnings: LintMessage[] = [];\n\n    for (const message of lintResult.messages) {\n      const lintMessage: LintMessage = {\n        type: message.severity === 2 ? \"error\" : \"warning\",\n        message: message.message,\n        lineNumber: message.line || 1,\n        columnNumber: message.column || 1,\n        length: message.endColumn && message.column ? message.endColumn - message.column : 1,\n        filePath: file.path,\n        relativePath: file.relativePath,\n        ruleId: message.ruleId || undefined,\n      };\n\n      if (message.severity === 2) {\n        errors.push(lintMessage);\n      } else if (message.severity === 1) {\n        warnings.push(lintMessage);\n      }\n    }\n\n    return {\n      path: file.path,\n      relativePath: file.relativePath,\n      healthy: errors.length === 0 && warnings.length === 0,\n      errors,\n      warnings,\n    };\n  }\n\n  /**\n   * Check if file is a lintable file\n   */\n  private isLintableFile(filePath: string): boolean {\n    const ext = filePath.toLowerCase();\n    return (\n      ext.endsWith(\".ts\") || ext.endsWith(\".tsx\") || ext.endsWith(\".js\") || ext.endsWith(\".jsx\")\n    );\n  }\n}\n\n// Create worker instance\nconst worker = new ESLintHealthWorker();\n\n// Handle messages from main thread\nparentPort?.on(\"message\", async (message: WorkerMessage) => {\n  try {\n    switch (message.type) {\n      case \"init\": {\n        const initResult = worker.initialize(message.config);\n        const response: WorkerResponse = {\n          type: \"initialized\",\n          success: initResult.success,\n          hasConfig: initResult.hasConfig,\n        };\n        parentPort?.postMessage(response);\n        break;\n      }\n\n      case \"check\": {\n        const results = await worker.checkFiles(message.files);\n        const response: WorkerResponse = { type: \"results\", results };\n        parentPort?.postMessage(response);\n        break;\n      }\n\n      case \"filesDeleted\": {\n        // ESLint doesn't maintain internal file cache (lints from memory)\n        // No cleanup needed, just acknowledge\n        break;\n      }\n\n      case \"shutdown\": {\n        process.exit(0);\n      }\n    }\n  } catch (error) {\n    const response: WorkerResponse = {\n      type: \"error\",\n      message: error instanceof Error ? error.message : String(error),\n    };\n    parentPort?.postMessage(response);\n  }\n});\n\n// Handle initialization from workerData if provided\nif (workerData?.autoInit) {\n  worker.initialize({ cwd: workerData.cwd || process.cwd() });\n}\n"],"mappings":"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"}

package/esm/dev-server/health-checker/workers/ts-health.worker.mjs

@@ -0,0 +1,212 @@
+import ts from "typescript";
+import { parentPort, workerData } from "worker_threads";
+
+//#region ../../@warlock.js/core/src/dev-server/health-checker/workers/ts-health.worker.ts
+/**
+* TypeScript Health Check Worker
+*
+* This worker runs in a dedicated thread to perform TypeScript type checking
+* without blocking the main dev server thread. It maintains a persistent
+* ts.Program instance for fast incremental type checking.
+*
+* Communication:
+* - Receives: { type: 'init' | 'check' | 'fileChanges' | 'shutdown', ... }
+* - Sends: { type: 'results' | 'initialized' | 'error', ... }
+*/
+/**
+* TypeScript Health Worker class
+* Maintains persistent ts.Program for incremental type checking
+*/
+var TypeScriptHealthWorker = class {
+	constructor() {
+		this.program = null;
+		this.parsedConfig = null;
+		this.fileContents = /* @__PURE__ */ new Map();
+		this.initialized = false;
+		this.cwd = process.cwd();
+	}
+	/**
+	* Initialize the worker with TypeScript configuration
+	*/
+	initialize(config) {
+		try {
+			this.cwd = config.cwd || process.cwd();
+			const tsconfigPath = config.tsconfigPath || ts.findConfigFile(this.cwd, ts.sys.fileExists);
+			if (!tsconfigPath) {
+				this.initialized = true;
+				return true;
+			}
+			const configFile = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
+			if (configFile.error) {
+				console.warn("TypeScript Worker: Error reading tsconfig:", configFile.error);
+				this.initialized = true;
+				return true;
+			}
+			this.parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, this.cwd);
+			if (this.parsedConfig.errors.length > 0) console.warn("TypeScript Worker: tsconfig has errors:", this.parsedConfig.errors);
+			this.initialized = true;
+			return true;
+		} catch (error) {
+			console.error("TypeScript Worker: Failed to initialize:", error);
+			this.initialized = true;
+			return false;
+		}
+	}
+	/**
+	* Check files for TypeScript errors
+	*/
+	checkFiles(files) {
+		if (!this.parsedConfig) return files.map((file) => ({
+			path: file.path,
+			relativePath: file.relativePath,
+			healthy: true,
+			errors: [],
+			warnings: []
+		}));
+		for (const file of files) this.fileContents.set(file.path, file.content);
+		this.program = ts.createProgram(Array.from(this.fileContents.keys()), this.parsedConfig.options, this.createCompilerHost(), this.program || void 0);
+		const results = [];
+		for (const file of files) {
+			const result = this.checkSingleFile(file);
+			results.push(result);
+		}
+		return results;
+	}
+	/**
+	* Handle file changes (update program incrementally)
+	*/
+	handleFileChanges(files) {
+		for (const file of files) this.fileContents.set(file.path, file.content);
+		if (this.parsedConfig && this.program) this.program = ts.createProgram(Array.from(this.fileContents.keys()), this.parsedConfig.options, this.createCompilerHost(), this.program || void 0);
+	}
+	/**
+	* Handle deleted files (remove from cache)
+	*/
+	handleFilesDeleted(files) {
+		let hasChanges = false;
+		for (const file of files) if (this.fileContents.has(file.path)) {
+			this.fileContents.delete(file.path);
+			hasChanges = true;
+		}
+		if (hasChanges && this.parsedConfig) this.program = ts.createProgram(Array.from(this.fileContents.keys()), this.parsedConfig.options, this.createCompilerHost(), this.program || void 0);
+	}
+	/**
+	* Check a single file for diagnostics
+	*/
+	checkSingleFile(file) {
+		if (!this.program) return {
+			path: file.path,
+			relativePath: file.relativePath,
+			healthy: true,
+			errors: [],
+			warnings: []
+		};
+		const sourceFile = this.program.getSourceFile(file.path);
+		if (!sourceFile) return {
+			path: file.path,
+			relativePath: file.relativePath,
+			healthy: true,
+			errors: [],
+			warnings: []
+		};
+		const syntacticDiagnostics = this.program.getSyntacticDiagnostics(sourceFile);
+		const semanticDiagnostics = this.program.getSemanticDiagnostics(sourceFile);
+		const allDiagnostics = [...syntacticDiagnostics, ...semanticDiagnostics];
+		const errors = [];
+		const warnings = [];
+		for (const diagnostic of allDiagnostics) {
+			const message = this.formatDiagnostic(diagnostic, file);
+			if (diagnostic.category === ts.DiagnosticCategory.Error) errors.push(message);
+			else if (diagnostic.category === ts.DiagnosticCategory.Warning) warnings.push(message);
+		}
+		return {
+			path: file.path,
+			relativePath: file.relativePath,
+			healthy: errors.length === 0 && warnings.length === 0,
+			errors,
+			warnings
+		};
+	}
+	/**
+	* Format a TypeScript diagnostic into our message format
+	*/
+	formatDiagnostic(diagnostic, file) {
+		let lineNumber = 1;
+		let columnNumber = 1;
+		let length = 1;
+		if (diagnostic.file && diagnostic.start !== void 0) {
+			const pos = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+			lineNumber = pos.line + 1;
+			columnNumber = pos.character + 1;
+			length = diagnostic.length || 1;
+		}
+		const messageText = typeof diagnostic.messageText === "string" ? diagnostic.messageText : diagnostic.messageText.messageText;
+		return {
+			type: diagnostic.category === ts.DiagnosticCategory.Error ? "error" : "warning",
+			message: messageText,
+			lineNumber,
+			columnNumber,
+			length,
+			filePath: file.path,
+			relativePath: file.relativePath
+		};
+	}
+	/**
+	* Create a custom compiler host that reads from in-memory cache
+	*/
+	createCompilerHost() {
+		const defaultHost = ts.createCompilerHost(this.parsedConfig?.options || {});
+		return {
+			...defaultHost,
+			readFile: (fileName) => {
+				if (this.fileContents.has(fileName)) return this.fileContents.get(fileName);
+				return defaultHost.readFile(fileName);
+			},
+			fileExists: (fileName) => {
+				if (this.fileContents.has(fileName)) return true;
+				return defaultHost.fileExists(fileName);
+			}
+		};
+	}
+};
+const worker = new TypeScriptHealthWorker();
+parentPort?.on("message", (message) => {
+	try {
+		switch (message.type) {
+			case "init": {
+				const response = {
+					type: "initialized",
+					success: worker.initialize(message.config)
+				};
+				parentPort?.postMessage(response);
+				break;
+			}
+			case "check": {
+				const response = {
+					type: "results",
+					results: worker.checkFiles(message.files)
+				};
+				parentPort?.postMessage(response);
+				break;
+			}
+			case "fileChanges":
+				worker.handleFileChanges(message.files);
+				break;
+			case "filesDeleted":
+				worker.handleFilesDeleted(message.files);
+				break;
+			case "shutdown": process.exit(0);
+		}
+	} catch (error) {
+		const response = {
+			type: "error",
+			message: error instanceof Error ? error.message : String(error)
+		};
+		parentPort?.postMessage(response);
+	}
+});
+if (workerData?.autoInit) worker.initialize({ cwd: workerData.cwd || process.cwd() });
+
+//#endregion
+export {  };
+//# sourceMappingURL=ts-health.worker.mjs.map

package/esm/dev-server/health-checker/workers/ts-health.worker.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-health.worker.mjs","names":[],"sources":["../../../../../../../../@warlock.js/core/src/dev-server/health-checker/workers/ts-health.worker.ts"],"sourcesContent":["/**\n * TypeScript Health Check Worker\n *\n * This worker runs in a dedicated thread to perform TypeScript type checking\n * without blocking the main dev server thread. It maintains a persistent\n * ts.Program instance for fast incremental type checking.\n *\n * Communication:\n * - Receives: { type: 'init' | 'check' | 'fileChanges' | 'shutdown', ... }\n * - Sends: { type: 'results' | 'initialized' | 'error', ... }\n */\nimport ts from \"typescript\";\nimport { parentPort, workerData } from \"worker_threads\";\n\n/**\n * Serialized file data received from main thread\n */\ntype SerializedFile = {\n  /** Absolute file path */\n  path: string;\n  /** File content (source code) */\n  content: string;\n  /** Relative path for display */\n  relativePath: string;\n};\n\n/**\n * Diagnostic message sent back to main thread\n */\ntype DiagnosticMessage = {\n  type: \"error\" | \"warning\";\n  message: string;\n  lineNumber: number;\n  columnNumber: number;\n  length: number;\n  filePath: string;\n  relativePath: string;\n};\n\n/**\n * Health check result for a single file\n */\ntype FileCheckResult = {\n  path: string;\n  relativePath: string;\n  healthy: boolean;\n  errors: DiagnosticMessage[];\n  warnings: DiagnosticMessage[];\n};\n\n/**\n * Messages received from main thread\n */\n/**\n * Deleted file info\n */\ntype DeletedFile = {\n  path: string;\n  relativePath: string;\n};\n\n/**\n * Messages received from main thread\n */\ntype WorkerMessage =\n  | { type: \"init\"; config: { cwd: string; tsconfigPath?: string } }\n  | { type: \"check\"; files: SerializedFile[] }\n  | { type: \"fileChanges\"; files: SerializedFile[] }\n  | { type: \"filesDeleted\"; files: DeletedFile[] }\n  | { type: \"shutdown\" };\n\n/**\n * Messages sent to main thread\n */\ntype WorkerResponse =\n  | { type: \"initialized\"; success: boolean; error?: string }\n  | { type: \"results\"; results: FileCheckResult[] }\n  | { type: \"error\"; message: string };\n\n/**\n * TypeScript Health Worker class\n * Maintains persistent ts.Program for incremental type checking\n */\nclass TypeScriptHealthWorker {\n  /**\n   * Cached TypeScript program instance\n   */\n  private program: ts.Program | null = null;\n\n  /**\n   * Parsed TypeScript configuration\n   */\n  private parsedConfig: ts.ParsedCommandLine | null = null;\n\n  /**\n   * In-memory file contents cache\n   */\n  private fileContents = new Map<string, string>();\n\n  /**\n   * Whether the worker is initialized\n   */\n  private initialized = false;\n\n  /**\n   * Current working directory\n   */\n  private cwd: string = process.cwd();\n\n  /**\n   * Initialize the worker with TypeScript configuration\n   */\n  public initialize(config: { cwd: string; tsconfigPath?: string }): boolean {\n    try {\n      this.cwd = config.cwd || process.cwd();\n\n      // Try to load tsconfig.json\n      const tsconfigPath = config.tsconfigPath || ts.findConfigFile(this.cwd, ts.sys.fileExists);\n\n      if (!tsconfigPath) {\n        this.initialized = true;\n        return true; // No tsconfig, will skip type checking\n      }\n\n      const configFile = ts.readConfigFile(tsconfigPath, ts.sys.readFile);\n\n      if (configFile.error) {\n        console.warn(\"TypeScript Worker: Error reading tsconfig:\", configFile.error);\n        this.initialized = true;\n        return true;\n      }\n\n      this.parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, this.cwd);\n\n      if (this.parsedConfig.errors.length > 0) {\n        console.warn(\"TypeScript Worker: tsconfig has errors:\", this.parsedConfig.errors);\n      }\n\n      this.initialized = true;\n      return true;\n    } catch (error) {\n      console.error(\"TypeScript Worker: Failed to initialize:\", error);\n      this.initialized = true;\n      return false;\n    }\n  }\n\n  /**\n   * Check files for TypeScript errors\n   */\n  public checkFiles(files: SerializedFile[]): FileCheckResult[] {\n    if (!this.parsedConfig) {\n      // No config, return all files as healthy\n      return files.map((file) => ({\n        path: file.path,\n        relativePath: file.relativePath,\n        healthy: true,\n        errors: [],\n        warnings: [],\n      }));\n    }\n\n    // Update in-memory file cache\n    for (const file of files) {\n      this.fileContents.set(file.path, file.content);\n    }\n\n    // Create or update the program (incremental)\n    this.program = ts.createProgram(\n      Array.from(this.fileContents.keys()),\n      this.parsedConfig.options,\n      this.createCompilerHost(),\n      this.program || undefined, // Pass old program for incremental compilation\n    );\n\n    // Check each file\n    const results: FileCheckResult[] = [];\n\n    for (const file of files) {\n      const result = this.checkSingleFile(file);\n      results.push(result);\n    }\n\n    return results;\n  }\n\n  /**\n   * Handle file changes (update program incrementally)\n   */\n  public handleFileChanges(files: SerializedFile[]): void {\n    for (const file of files) {\n      this.fileContents.set(file.path, file.content);\n    }\n\n    // Recreate program with new file contents\n    if (this.parsedConfig && this.program) {\n      this.program = ts.createProgram(\n        Array.from(this.fileContents.keys()),\n        this.parsedConfig.options,\n        this.createCompilerHost(),\n        this.program || undefined,\n      );\n    }\n  }\n\n  /**\n   * Handle deleted files (remove from cache)\n   */\n  public handleFilesDeleted(files: DeletedFile[]): void {\n    let hasChanges = false;\n\n    for (const file of files) {\n      if (this.fileContents.has(file.path)) {\n        this.fileContents.delete(file.path);\n        hasChanges = true;\n      }\n    }\n\n    // Recreate program without deleted files\n    if (hasChanges && this.parsedConfig) {\n      this.program = ts.createProgram(\n        Array.from(this.fileContents.keys()),\n        this.parsedConfig.options,\n        this.createCompilerHost(),\n        this.program || undefined,\n      );\n    }\n  }\n\n  /**\n   * Check a single file for diagnostics\n   */\n  private checkSingleFile(file: SerializedFile): FileCheckResult {\n    if (!this.program) {\n      return {\n        path: file.path,\n        relativePath: file.relativePath,\n        healthy: true,\n        errors: [],\n        warnings: [],\n      };\n    }\n\n    const sourceFile = this.program.getSourceFile(file.path);\n\n    if (!sourceFile) {\n      return {\n        path: file.path,\n        relativePath: file.relativePath,\n        healthy: true,\n        errors: [],\n        warnings: [],\n      };\n    }\n\n    const syntacticDiagnostics = this.program.getSyntacticDiagnostics(sourceFile);\n    const semanticDiagnostics = this.program.getSemanticDiagnostics(sourceFile);\n    const allDiagnostics = [...syntacticDiagnostics, ...semanticDiagnostics];\n\n    const errors: DiagnosticMessage[] = [];\n    const warnings: DiagnosticMessage[] = [];\n\n    for (const diagnostic of allDiagnostics) {\n      const message = this.formatDiagnostic(diagnostic, file);\n\n      if (diagnostic.category === ts.DiagnosticCategory.Error) {\n        errors.push(message);\n      } else if (diagnostic.category === ts.DiagnosticCategory.Warning) {\n        warnings.push(message);\n      }\n    }\n\n    return {\n      path: file.path,\n      relativePath: file.relativePath,\n      healthy: errors.length === 0 && warnings.length === 0,\n      errors,\n      warnings,\n    };\n  }\n\n  /**\n   * Format a TypeScript diagnostic into our message format\n   */\n  private formatDiagnostic(diagnostic: ts.Diagnostic, file: SerializedFile): DiagnosticMessage {\n    let lineNumber = 1;\n    let columnNumber = 1;\n    let length = 1;\n\n    if (diagnostic.file && diagnostic.start !== undefined) {\n      const pos = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);\n      lineNumber = pos.line + 1;\n      columnNumber = pos.character + 1;\n      length = diagnostic.length || 1;\n    }\n\n    const messageText =\n      typeof diagnostic.messageText === \"string\"\n        ? diagnostic.messageText\n        : diagnostic.messageText.messageText;\n\n    return {\n      type: diagnostic.category === ts.DiagnosticCategory.Error ? \"error\" : \"warning\",\n      message: messageText,\n      lineNumber,\n      columnNumber,\n      length,\n      filePath: file.path,\n      relativePath: file.relativePath,\n    };\n  }\n\n  /**\n   * Create a custom compiler host that reads from in-memory cache\n   */\n  private createCompilerHost(): ts.CompilerHost {\n    const defaultHost = ts.createCompilerHost(this.parsedConfig?.options || {});\n\n    return {\n      ...defaultHost,\n      readFile: (fileName: string) => {\n        // Check in-memory cache first\n        if (this.fileContents.has(fileName)) {\n          return this.fileContents.get(fileName);\n        }\n        // Fall back to disk\n        return defaultHost.readFile(fileName);\n      },\n      fileExists: (fileName: string) => {\n        if (this.fileContents.has(fileName)) {\n          return true;\n        }\n        return defaultHost.fileExists(fileName);\n      },\n    };\n  }\n}\n\n// Create worker instance\nconst worker = new TypeScriptHealthWorker();\n\n// Handle messages from main thread\nparentPort?.on(\"message\", (message: WorkerMessage) => {\n  try {\n    switch (message.type) {\n      case \"init\": {\n        const success = worker.initialize(message.config);\n        const response: WorkerResponse = { type: \"initialized\", success };\n        parentPort?.postMessage(response);\n        break;\n      }\n\n      case \"check\": {\n        const results = worker.checkFiles(message.files);\n        const response: WorkerResponse = { type: \"results\", results };\n        parentPort?.postMessage(response);\n        break;\n      }\n\n      case \"fileChanges\": {\n        worker.handleFileChanges(message.files);\n        break;\n      }\n\n      case \"filesDeleted\": {\n        worker.handleFilesDeleted(message.files);\n        break;\n      }\n\n      case \"shutdown\": {\n        process.exit(0);\n      }\n    }\n  } catch (error) {\n    const response: WorkerResponse = {\n      type: \"error\",\n      message: error instanceof Error ? error.message : String(error),\n    };\n    parentPort?.postMessage(response);\n  }\n});\n\n// Handle initialization from workerData if provided\nif (workerData?.autoInit) {\n  worker.initialize({ cwd: workerData.cwd || process.cwd() });\n}\n"],"mappings":"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"}

package/esm/dev-server/layer-executor.mjs

@@ -0,0 +1,114 @@
+import { devLogHMR } from "./dev-logger.mjs";
+import { connectorsManager } from "../connectors/connectors-manager.mjs";
+import { configManager } from "../config/config-manager.mjs";
+import { loadEnv } from "@mongez/dotenv";
+
+//#region ../../@warlock.js/core/src/dev-server/layer-executor.ts
+/**
+* Decides what to reload when a batch of files changes.
+*
+* Strategy: bump the hook's version counter for every file in the
+* invalidation chain, wait for the hook worker to flush, then re-import
+* any special files (config / main / routes / events / locales) the chain
+* touched and restart any connector whose watched-files overlap the change.
+*/
+var LayerExecutor = class {
+	constructor(dependencyGraph, specialFilesCollector, moduleLoader, bumpVersion, flushVersionBumps) {
+		this.dependencyGraph = dependencyGraph;
+		this.specialFilesCollector = specialFilesCollector;
+		this.moduleLoader = moduleLoader;
+		this.bumpVersion = bumpVersion;
+		this.flushVersionBumps = flushVersionBumps;
+	}
+	/**
+	* Entry point for the file watcher batch.
+	*
+	* @param changedPaths - code files added or changed in this batch
+	* @param filesMap - all tracked files (relativePath → FileManager)
+	* @param deletedFiles - paths that were removed from disk
+	* @param allChangedPaths - includes .env so we can detect config reloads
+	*/
+	async executeBatchReload(changedPaths, filesMap, deletedFiles, allChangedPaths) {
+		const envFilesChanged = (allChangedPaths ?? []).some(isEnvPath);
+		if (changedPaths.length === 0 && deletedFiles.length === 0 && !envFilesChanged) return;
+		for (const path of deletedFiles) {
+			const file = filesMap.get(path);
+			if (file) this.moduleLoader.cleanupDeletedModule(file);
+		}
+		if (changedPaths.length === 0 && envFilesChanged) {
+			const configPaths = await this.reloadAffectedModules([".env"], filesMap);
+			await this.restartAffectedConnectors(configPaths);
+			return;
+		}
+		if (changedPaths.length === 0) return;
+		const invalidationChain = /* @__PURE__ */ new Set();
+		for (const path of changedPaths) {
+			for (const file of this.dependencyGraph.getInvalidationChain(path)) invalidationChain.add(file);
+			devLogHMR(path, invalidationChain.size - 1);
+		}
+		const chain = Array.from(invalidationChain);
+		for (const relativePath of chain) {
+			const file = filesMap.get(relativePath);
+			if (!file) continue;
+			this.moduleLoader.runCleanup(file);
+			this.bumpVersion(file.absolutePath);
+			await file.process({ force: true });
+		}
+		await this.flushVersionBumps();
+		const affectedConfigPaths = await this.reloadAffectedModules(chain, filesMap);
+		await this.restartAffectedConnectors([...changedPaths, ...affectedConfigPaths]);
+	}
+	async restartAffectedConnectors(affectedFiles) {
+		const toRestart = connectorsManager.list().filter((connector) => connector.shouldRestart(affectedFiles));
+		for (const connector of toRestart) await connector.restart();
+	}
+	/**
+	* Re-import every special file whose path or dependency-set intersects the
+	* invalidation chain. Returns the relative paths of any config files that
+	* reloaded so the caller can pass them to the connector-restart pass.
+	*/
+	async reloadAffectedModules(chain, filesMap) {
+		const isEnvAffected = chain.some(isEnvPath);
+		if (isEnvAffected) await loadEnv();
+		const isAffected = (file) => isFileAffected(file, chain);
+		const affectedModels = chain.map((path) => filesMap.get(path)).filter((file) => !!file && file.type === "model");
+		for (const file of affectedModels) await this.moduleLoader.loadModule(file, "model");
+		const collector = this.specialFilesCollector;
+		const affectedConfigs = collector.getFilesByType("config").filter((file) => isEnvAffected ? true : isAffected(file));
+		const affectedMains = collector.getFilesByType("main").filter(isAffected);
+		const affectedRoutes = collector.getFilesByType("route").filter(isAffected);
+		const affectedEvents = collector.getFilesByType("event").filter(isAffected);
+		const affectedLocales = collector.getFilesByType("locale").filter(isAffected);
+		if (!(affectedConfigs.length > 0 || affectedMains.length > 0 || affectedRoutes.length > 0 || affectedEvents.length > 0 || affectedLocales.length > 0)) {
+			const tail = filesMap.get(chain[chain.length - 1]);
+			if (tail) await this.moduleLoader.reloadModule(tail);
+			return [];
+		}
+		const configPaths = [];
+		for (const file of affectedConfigs) {
+			await configManager.reload(file);
+			configPaths.push(file.relativePath);
+		}
+		for (const file of affectedLocales) await this.moduleLoader.reloadModule(file);
+		for (const file of affectedMains) await this.moduleLoader.reloadModule(file);
+		for (const file of affectedEvents) await this.moduleLoader.reloadModule(file);
+		for (const file of affectedRoutes) await this.moduleLoader.reloadModule(file);
+		return configPaths;
+	}
+};
+function isEnvPath(path) {
+	const basename = path.split("/").pop() ?? path;
+	return basename === ".env" || basename.startsWith(".env.");
+}
+/**
+* A file is "affected" if it itself is in the chain or imports something in it.
+*/
+function isFileAffected(file, chain) {
+	if (chain.includes(file.relativePath)) return true;
+	for (const dep of file.dependencies) if (chain.includes(dep)) return true;
+	return false;
+}
+
+//#endregion
+export { LayerExecutor };
+//# sourceMappingURL=layer-executor.mjs.map

package/esm/dev-server/layer-executor.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"layer-executor.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/dev-server/layer-executor.ts"],"sourcesContent":["import { loadEnv } from \"@mongez/dotenv\";\r\nimport { configManager } from \"../config/config-manager\";\r\nimport { connectorsManager } from \"../connectors/connectors-manager\";\r\nimport type { DependencyGraph } from \"./dependency-graph\";\r\nimport { devLogHMR } from \"./dev-logger\";\r\nimport { FileManager } from \"./file-manager\";\r\nimport type { ModuleLoader } from \"./module-loader\";\r\nimport type { SpecialFilesCollector } from \"./special-files-collector\";\r\n\r\n/**\r\n * Decides what to reload when a batch of files changes.\r\n *\r\n * Strategy: bump the hook's version counter for every file in the\r\n * invalidation chain, wait for the hook worker to flush, then re-import\r\n * any special files (config / main / routes / events / locales) the chain\r\n * touched and restart any connector whose watched-files overlap the change.\r\n */\r\nexport class LayerExecutor {\r\n  public constructor(\r\n    private readonly dependencyGraph: DependencyGraph,\r\n    private readonly specialFilesCollector: SpecialFilesCollector,\r\n    private readonly moduleLoader: ModuleLoader,\r\n    private readonly bumpVersion: (absolutePath: string) => void,\r\n    private readonly flushVersionBumps: () => Promise<void>,\r\n  ) {}\r\n\r\n  /**\r\n   * Entry point for the file watcher batch.\r\n   *\r\n   * @param changedPaths - code files added or changed in this batch\r\n   * @param filesMap - all tracked files (relativePath → FileManager)\r\n   * @param deletedFiles - paths that were removed from disk\r\n   * @param allChangedPaths - includes .env so we can detect config reloads\r\n   */\r\n  public async executeBatchReload(\r\n    changedPaths: string[],\r\n    filesMap: Map<string, FileManager>,\r\n    deletedFiles: string[],\r\n    allChangedPaths?: string[],\r\n  ): Promise<void> {\r\n    const envFilesChanged = (allChangedPaths ?? []).some(isEnvPath);\r\n\r\n    if (changedPaths.length === 0 && deletedFiles.length === 0 && !envFilesChanged) {\r\n      return;\r\n    }\r\n\r\n    // Deletes: clean up routes/cleanup hooks for files that no longer exist.\r\n    for (const path of deletedFiles) {\r\n      const file = filesMap.get(path);\r\n      if (file) this.moduleLoader.cleanupDeletedModule(file);\r\n    }\r\n\r\n    // Env-only change: reload all configs, restart connectors that watch them.\r\n    if (changedPaths.length === 0 && envFilesChanged) {\r\n      const configPaths = await this.reloadAffectedModules([\".env\"], filesMap);\r\n      await this.restartAffectedConnectors(configPaths);\r\n      return;\r\n    }\r\n\r\n    if (changedPaths.length === 0) return;\r\n\r\n    const invalidationChain = new Set<string>();\r\n    for (const path of changedPaths) {\r\n      for (const file of this.dependencyGraph.getInvalidationChain(path)) {\r\n        invalidationChain.add(file);\r\n      }\r\n      devLogHMR(path, invalidationChain.size - 1);\r\n    }\r\n\r\n    const chain = Array.from(invalidationChain);\r\n\r\n    // Step 1: bump version counters so the next import() is fresh.\r\n    for (const relativePath of chain) {\r\n      const file = filesMap.get(relativePath);\r\n      if (!file) continue;\r\n      this.moduleLoader.runCleanup(file);\r\n      this.bumpVersion(file.absolutePath);\r\n      await file.process({ force: true });\r\n    }\r\n\r\n    // Step 2: wait for the hook worker to ack every bump.\r\n    // Without this, resolve() may still return the old ?v=N URL.\r\n    await this.flushVersionBumps();\r\n\r\n    // Step 3: re-import affected special files.\r\n    const affectedConfigPaths = await this.reloadAffectedModules(chain, filesMap);\r\n\r\n    // Step 4: restart any connector whose watched-files overlap the chain.\r\n    await this.restartAffectedConnectors([...changedPaths, ...affectedConfigPaths]);\r\n  }\r\n\r\n  private async restartAffectedConnectors(affectedFiles: string[]): Promise<void> {\r\n    const toRestart = connectorsManager\r\n      .list()\r\n      .filter(connector => connector.shouldRestart(affectedFiles));\r\n\r\n    for (const connector of toRestart) {\r\n      await connector.restart();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Re-import every special file whose path or dependency-set intersects the\r\n   * invalidation chain. Returns the relative paths of any config files that\r\n   * reloaded so the caller can pass them to the connector-restart pass.\r\n   */\r\n  private async reloadAffectedModules(\r\n    chain: string[],\r\n    filesMap: Map<string, FileManager>,\r\n  ): Promise<string[]> {\r\n    const isEnvAffected = chain.some(isEnvPath);\r\n    if (isEnvAffected) await loadEnv();\r\n\r\n    const isAffected = (file: FileManager) => isFileAffected(file, chain);\r\n\r\n    // Models self-register via the @RegisterModel decorator and rely on the\r\n    // module-loader's registerCleanup() to attach Model.$cleanup (which\r\n    // unregisters them on the next reload). That only happens inside\r\n    // loadModule(), which models hit exactly once — at boot, via\r\n    // autoDiscoverFiles. During HMR they're otherwise re-imported\r\n    // *transitively* through routes, which never re-runs registerCleanup, so\r\n    // after the first reload the cleanup list is empty and the registration\r\n    // leaks (\"Model X is already registered\" on every subsequent edit).\r\n    //\r\n    // Re-importing changed model files through loadModule here re-attaches\r\n    // $cleanup every cycle. It runs before the route pass so the decorator\r\n    // registers once; the transitive route import then hits the cached ?v=N\r\n    // and does not double-register.\r\n    const affectedModels = chain\r\n      .map(path => filesMap.get(path))\r\n      .filter((file): file is FileManager => !!file && file.type === \"model\");\r\n\r\n    for (const file of affectedModels) {\r\n      await this.moduleLoader.loadModule(file, \"model\");\r\n    }\r\n\r\n    const collector = this.specialFilesCollector;\r\n    const affectedConfigs = collector\r\n      .getFilesByType(\"config\")\r\n      .filter(file => (isEnvAffected ? true : isAffected(file)));\r\n    const affectedMains = collector.getFilesByType(\"main\").filter(isAffected);\r\n    const affectedRoutes = collector.getFilesByType(\"route\").filter(isAffected);\r\n    const affectedEvents = collector.getFilesByType(\"event\").filter(isAffected);\r\n    const affectedLocales = collector.getFilesByType(\"locale\").filter(isAffected);\r\n\r\n    const hasSpecialFiles =\r\n      affectedConfigs.length > 0 ||\r\n      affectedMains.length > 0 ||\r\n      affectedRoutes.length > 0 ||\r\n      affectedEvents.length > 0 ||\r\n      affectedLocales.length > 0;\r\n\r\n    // No entry points touched: reloading internal files alone is wasted work\r\n    // because the hook will re-import them on next access anyway. But the\r\n    // dep chain's last hop is usually the user-facing edge — give it a kick.\r\n    if (!hasSpecialFiles) {\r\n      const tail = filesMap.get(chain[chain.length - 1]);\r\n      if (tail) await this.moduleLoader.reloadModule(tail);\r\n      return [];\r\n    }\r\n\r\n    const configPaths: string[] = [];\r\n    for (const file of affectedConfigs) {\r\n      await configManager.reload(file);\r\n      configPaths.push(file.relativePath);\r\n    }\r\n\r\n    // Order matters: locales first (translations used by main), main before\r\n    // routes (registers state routes consume), events between (listeners).\r\n    for (const file of affectedLocales) await this.moduleLoader.reloadModule(file);\r\n    for (const file of affectedMains) await this.moduleLoader.reloadModule(file);\r\n    for (const file of affectedEvents) await this.moduleLoader.reloadModule(file);\r\n    for (const file of affectedRoutes) await this.moduleLoader.reloadModule(file);\r\n\r\n    return configPaths;\r\n  }\r\n}\r\n\r\nfunction isEnvPath(path: string): boolean {\r\n  const basename = path.split(\"/\").pop() ?? path;\r\n  return basename === \".env\" || basename.startsWith(\".env.\");\r\n}\r\n\r\n/**\r\n * A file is \"affected\" if it itself is in the chain or imports something in it.\r\n */\r\nfunction isFileAffected(file: FileManager, chain: string[]): boolean {\r\n  if (chain.includes(file.relativePath)) return true;\r\n  for (const dep of file.dependencies) {\r\n    if (chain.includes(dep)) return true;\r\n  }\r\n  return false;\r\n}\r\n"],"mappings":"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"}

package/esm/dev-server/loader/build-transpile-init.mjs

@@ -0,0 +1,49 @@
+import { warlockPath } from "../../utils/paths.mjs";
+import "../../utils/index.mjs";
+import { computeFingerprint } from "./transpile-cache.mjs";
+import { version } from "esbuild";
+
+//#region ../../@warlock.js/core/src/dev-server/loader/build-transpile-init.ts
+/**
+* esbuild `target` for the dev transform. Pinned to the same value the
+* production builder uses so dev and prod lower TC39 decorators (Cascade
+* leans on them) to identical helper output — a file transpiled in dev and
+* the same file built for prod must behave the same.
+*/
+const TRANSPILE_TARGET = "node22";
+/**
+* Build the transpile payload shipped into the hook worker. Always
+* returned — esbuild transpile is unconditional (tsx is no longer in the
+* TypeScript path); persistence to `.warlock/transpile` is intrinsic.
+*
+* The fingerprint folds esbuild's version, the cache-format epoch and the
+* whole tsconfig `compilerOptions` blob (plus the target) so any change to
+* the transform contract invalidates every entry structurally — no sweep,
+* no stale output.
+*
+* @param compilerOptions - Raw tsconfig `compilerOptions` (handed to esbuild
+*   as `tsconfigRaw` and hashed wholesale into the fingerprint).
+* @param debugNames - `devServer.transpileCacheDebug` — cosmetic readable
+*   cache filenames. Default off.
+*/
+function buildTranspileInit(compilerOptions, debugNames) {
+	const fingerprint = computeFingerprint({
+		esbuildVersion: version,
+		cacheEpoch: 1,
+		compilerOptions: {
+			compilerOptions,
+			target: TRANSPILE_TARGET
+		}
+	});
+	return {
+		cacheDir: warlockPath("transpile"),
+		fingerprint,
+		target: TRANSPILE_TARGET,
+		tsconfigRaw: JSON.stringify({ compilerOptions: compilerOptions ?? {} }),
+		debugNames
+	};
+}
+
+//#endregion
+export { buildTranspileInit };
+//# sourceMappingURL=build-transpile-init.mjs.map

package/esm/dev-server/loader/build-transpile-init.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-transpile-init.mjs","names":[],"sources":["../../../../../../../@warlock.js/core/src/dev-server/loader/build-transpile-init.ts"],"sourcesContent":["import { version as esbuildVersion } from \"esbuild\";\nimport { warlockPath } from \"../../utils\";\nimport type { TranspileInit } from \"./load-hook.js\";\nimport { CACHE_EPOCH, computeFingerprint } from \"./transpile-cache.js\";\n\n/**\n * esbuild `target` for the dev transform. Pinned to the same value the\n * production builder uses so dev and prod lower TC39 decorators (Cascade\n * leans on them) to identical helper output — a file transpiled in dev and\n * the same file built for prod must behave the same.\n */\nconst TRANSPILE_TARGET = \"node22\";\n\n/**\n * Build the transpile payload shipped into the hook worker. Always\n * returned — esbuild transpile is unconditional (tsx is no longer in the\n * TypeScript path); persistence to `.warlock/transpile` is intrinsic.\n *\n * The fingerprint folds esbuild's version, the cache-format epoch and the\n * whole tsconfig `compilerOptions` blob (plus the target) so any change to\n * the transform contract invalidates every entry structurally — no sweep,\n * no stale output.\n *\n * @param compilerOptions - Raw tsconfig `compilerOptions` (handed to esbuild\n *   as `tsconfigRaw` and hashed wholesale into the fingerprint).\n * @param debugNames - `devServer.transpileCacheDebug` — cosmetic readable\n *   cache filenames. Default off.\n */\nexport function buildTranspileInit(\n  compilerOptions: unknown,\n  debugNames: boolean,\n): TranspileInit {\n  const fingerprint = computeFingerprint({\n    esbuildVersion,\n    cacheEpoch: CACHE_EPOCH,\n    compilerOptions: { compilerOptions, target: TRANSPILE_TARGET },\n  });\n\n  return {\n    cacheDir: warlockPath(\"transpile\"),\n    fingerprint,\n    target: TRANSPILE_TARGET,\n    tsconfigRaw: JSON.stringify({ compilerOptions: compilerOptions ?? {} }),\n    debugNames,\n  };\n}\n"],"mappings":";;;;;;;;;;;;AAWA,MAAM,mBAAmB;;;;;;;;;;;;;;;;AAiBzB,SAAgB,mBACd,iBACA,YACe;CACf,MAAM,cAAc,mBAAmB;EACrC;EACA;EACA,iBAAiB;GAAE;GAAiB,QAAQ;EAAiB;CAC/D,CAAC;CAED,OAAO;EACL,UAAU,YAAY,WAAW;EACjC;EACA,QAAQ;EACR,aAAa,KAAK,UAAU,EAAE,iBAAiB,mBAAmB,CAAC,EAAE,CAAC;EACtE;CACF;AACF"}