@warlock.js/core 4.1.15 → 4.2.1

package/esm/database/seeds/utils.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.mjs","names":[],"sources":["../../../../../../../@warlock.js/core/src/database/seeds/utils.ts"],"sourcesContent":["export const seedsTableName = \"_seeds\";\n"],"mappings":";AAAA,MAAa,iBAAiB"}

package/esm/dev-server/development-server.mjs

@@ -1,115 +0,0 @@
-import { ConnectorLifecyclePhase } from "../connectors/types.mjs";
-import { devLogReady, devLogSection, devLogWarn, devServeLog } from "./dev-logger.mjs";
-import { connectorsManager } from "../connectors/connectors-manager.mjs";
-import { warlockConfigManager } from "../warlock-config/warlock-config.manager.mjs";
-import { MANIFEST_PATH } from "./flags.mjs";
-import { filesOrchestrator } from "./files-orchestrator.mjs";
-import "../warlock-config/index.mjs";
-import { LayerExecutor } from "./layer-executor.mjs";
-import { typeGenerator } from "./type-generator.mjs";
-import { colors } from "@mongez/copper";
-import events from "@mongez/events";
-import { fileExistsAsync, getFileAsync, unlinkAsync } from "@warlock.js/fs";
-
-//#region ../../@warlock.js/core/src/dev-server/development-server.ts
-/**
-* Top-level coordinator for `warlock dev`. Wires the file orchestrator, the
-* connectors, and the layer executor together, and listens for the watcher's
-* batched events to drive HMR.
-*/
-var DevelopmentServer = class {
-	constructor(options = {}) {
-		this.running = false;
-		this.options = options;
-		devLogSection("Starting Development Server...");
-	}
-	async start() {
-		try {
-			const startedAt = performance.now();
-			if (this.options.fresh && await fileExistsAsync(MANIFEST_PATH)) {
-				await unlinkAsync(MANIFEST_PATH);
-				devServeLog(colors.cyanBright("Cleared manifest (--fresh)"));
-			}
-			await filesOrchestrator.init();
-			await filesOrchestrator.initializeAll();
-			await filesOrchestrator.watchFiles();
-			filesOrchestrator.specialFilesCollector.collect(filesOrchestrator.getFiles());
-			this.setupEventListeners();
-			await this.autoDiscoverFiles();
-			await filesOrchestrator.moduleLoader.loadAll();
-			await connectorsManager.startPhase("late");
-			this.layerExecutor = new LayerExecutor(filesOrchestrator.getDependencyGraph(), filesOrchestrator.specialFilesCollector, filesOrchestrator.moduleLoader, (absolutePath) => filesOrchestrator.bumpVersion(absolutePath), () => filesOrchestrator.flushVersionBumps());
-			this.running = true;
-			const duration = performance.now() - startedAt;
-			devLogReady(`Development Server is ready in ${colors.greenBright(parseDuration(duration))}`);
-			const devServerConfig = await warlockConfigManager.get("devServer");
-			const generateTypings = this.options.generateTypings ?? devServerConfig?.generateTypings ?? true;
-			const healthCheckers = this.options.healthCheckers ?? devServerConfig?.healthCheckers ?? true;
-			if (generateTypings) typeGenerator.executeGenerateAllCommand();
-			if (healthCheckers) filesOrchestrator.startCheckingHealth(healthCheckers === true ? void 0 : healthCheckers);
-		} catch (error) {
-			devServeLog(colors.redBright(`Failed to start Development Server: ${error}`));
-			await this.shutdown();
-			throw error;
-		}
-	}
-	/**
-	* Eagerly import files whose decorators populate global registries so any
-	* symbol-by-name resolution later in boot finds them.
-	*/
-	async autoDiscoverFiles() {
-		const discoveryTypes = ["model"];
-		for (const file of filesOrchestrator.files.values()) if (file.type && discoveryTypes.includes(file.type)) await filesOrchestrator.moduleLoader.loadModule(file, file.type);
-	}
-	setupEventListeners() {
-		events.on("dev-server:batch-complete", (batch) => this.handleBatchComplete(batch));
-	}
-	async handleBatchComplete(batch) {
-		if (!this.running || !this.layerExecutor) return;
-		if (batch.changed.includes("warlock.config.ts")) devLogWarn("warlock.config.ts changed — restart the dev server to apply.");
-		if (batch.changed.length > 0) batch.changed = await dropNoOpChanges(batch.changed);
-		if (batch.added.length + batch.changed.length + batch.deleted.length === 0) return;
-		const codeFiles = [...batch.added, ...batch.changed].filter((p) => !isEnvPath(p));
-		try {
-			await this.layerExecutor.executeBatchReload(codeFiles, filesOrchestrator.getFiles(), batch.deleted, batch.changed);
-			typeGenerator.executeTypingsGenerator([...batch.added, ...batch.changed]);
-			filesOrchestrator.checkHealth(batch);
-		} catch (error) {
-			devServeLog(colors.redBright(`Failed to execute batch reload: ${error}`));
-		}
-	}
-	async shutdown() {
-		if (!this.running) return;
-		devServeLog(colors.redBright("Shutting down Development Server..."));
-		this.running = false;
-		await connectorsManager.shutdown();
-		devServeLog(colors.greenBright("Development Server stopped"));
-	}
-	isRunning() {
-		return this.running;
-	}
-};
-async function dropNoOpChanges(changedPaths) {
-	return (await Promise.all(changedPaths.map(async (relativePath) => {
-		if (isEnvPath(relativePath)) return relativePath;
-		const file = filesOrchestrator.files.get(relativePath);
-		if (!file) return null;
-		const content = await getFileAsync(file.absolutePath);
-		if (content.trim() === file.source) return null;
-		file.source = content;
-		return relativePath;
-	}))).filter((p) => p !== null);
-}
-function isEnvPath(path) {
-	const basename = path.split("/").pop() ?? path;
-	return basename === ".env" || basename.startsWith(".env.");
-}
-function parseDuration(ms) {
-	if (ms < 1e3) return `${ms.toFixed(2)}ms`;
-	if (ms > 6e4) return `${(ms / 6e4).toFixed(2)}m`;
-	return `${(ms / 1e3).toFixed(2)}s`;
-}
-
-//#endregion
-export { DevelopmentServer };
-//# sourceMappingURL=development-server.mjs.map

package/esm/dev-server/development-server.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"development-server.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/dev-server/development-server.ts"],"sourcesContent":["import { colors } from \"@mongez/copper\";\r\nimport events from \"@mongez/events\";\r\nimport { fileExistsAsync, getFileAsync, unlinkAsync } from \"@warlock.js/fs\";\r\nimport { connectorsManager } from \"../connectors/connectors-manager\";\r\nimport { ConnectorLifecyclePhase } from \"../connectors/types\";\r\nimport { warlockConfigManager } from \"../warlock-config\";\r\nimport { devLogReady, devLogSection, devLogWarn, devServeLog } from \"./dev-logger\";\r\nimport { filesOrchestrator } from \"./files-orchestrator\";\r\nimport { MANIFEST_PATH } from \"./flags\";\r\nimport { LayerExecutor } from \"./layer-executor\";\r\nimport type { StartDevServerOptions } from \"./start-development-server\";\r\nimport { typeGenerator } from \"./type-generator\";\r\n\r\ntype Batch = { added: string[]; changed: string[]; deleted: string[] };\r\n\r\n/**\r\n * Top-level coordinator for `warlock dev`. Wires the file orchestrator, the\r\n * connectors, and the layer executor together, and listens for the watcher's\r\n * batched events to drive HMR.\r\n */\r\nexport class DevelopmentServer {\r\n  private layerExecutor?: LayerExecutor;\r\n  private running = false;\r\n  private readonly options: StartDevServerOptions;\r\n\r\n  public constructor(options: StartDevServerOptions = {}) {\r\n    this.options = options;\r\n    devLogSection(\"Starting Development Server...\");\r\n  }\r\n\r\n  public async start(): Promise<void> {\r\n    try {\r\n      const startedAt = performance.now();\r\n\r\n      // --fresh deletes the manifest so reconciliation re-parses every file\r\n      // from disk. Transpile caching is owned by the loader hook (in-memory).\r\n      if (this.options.fresh && (await fileExistsAsync(MANIFEST_PATH))) {\r\n        await unlinkAsync(MANIFEST_PATH);\r\n        devServeLog(colors.cyanBright(\"Cleared manifest (--fresh)\"));\r\n      }\r\n\r\n      await filesOrchestrator.init();\r\n      await filesOrchestrator.initializeAll();\r\n      await filesOrchestrator.watchFiles();\r\n\r\n      filesOrchestrator.specialFilesCollector.collect(filesOrchestrator.getFiles());\r\n\r\n      this.setupEventListeners();\r\n\r\n      // Decorator-driven registries (models, etc.) must be populated before\r\n      // routes/services can resolve symbols by name.\r\n      await this.autoDiscoverFiles();\r\n\r\n      await filesOrchestrator.moduleLoader.loadAll();\r\n\r\n      // Late-phase connectors (http, socket) bind after app code has\r\n      // registered routes/listeners.\r\n      await connectorsManager.startPhase(ConnectorLifecyclePhase.Late);\r\n\r\n      this.layerExecutor = new LayerExecutor(\r\n        filesOrchestrator.getDependencyGraph(),\r\n        filesOrchestrator.specialFilesCollector,\r\n        filesOrchestrator.moduleLoader,\r\n        (absolutePath) => filesOrchestrator.bumpVersion(absolutePath),\r\n        () => filesOrchestrator.flushVersionBumps(),\r\n      );\r\n\r\n      this.running = true;\r\n\r\n      const duration = performance.now() - startedAt;\r\n      devLogReady(`Development Server is ready in ${colors.greenBright(parseDuration(duration))}`);\r\n\r\n      // Precedence: explicit CLI option > devServer.* config > default.\r\n      const devServerConfig = await warlockConfigManager.get(\"devServer\");\r\n      const generateTypings =\r\n        this.options.generateTypings ?? devServerConfig?.generateTypings ?? true;\r\n      const healthCheckers = this.options.healthCheckers ?? devServerConfig?.healthCheckers ?? true;\r\n\r\n      if (generateTypings) typeGenerator.executeGenerateAllCommand();\r\n\r\n      if (healthCheckers) {\r\n        filesOrchestrator.startCheckingHealth(healthCheckers === true ? undefined : healthCheckers);\r\n      }\r\n    } catch (error) {\r\n      devServeLog(colors.redBright(`Failed to start Development Server: ${error}`));\r\n      await this.shutdown();\r\n      throw error;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Eagerly import files whose decorators populate global registries so any\r\n   * symbol-by-name resolution later in boot finds them.\r\n   */\r\n  private async autoDiscoverFiles(): Promise<void> {\r\n    const discoveryTypes = [\"model\"] as const;\r\n    for (const file of filesOrchestrator.files.values()) {\r\n      if (file.type && (discoveryTypes as readonly string[]).includes(file.type)) {\r\n        await filesOrchestrator.moduleLoader.loadModule(file, file.type);\r\n      }\r\n    }\r\n  }\r\n\r\n  private setupEventListeners(): void {\r\n    events.on(\"dev-server:batch-complete\", (batch: Batch) => this.handleBatchComplete(batch));\r\n  }\r\n\r\n  private async handleBatchComplete(batch: Batch): Promise<void> {\r\n    if (!this.running || !this.layerExecutor) return;\r\n\r\n    // warlock.config.ts holds settings read at boot (CLI commands, build\r\n    // options, watch patterns, scheduled jobs). Hot-reloading it would\r\n    // leave running services configured with stale values, so tell the\r\n    // dev they need a restart and don't pretend to apply the change.\r\n    if (batch.changed.includes(\"warlock.config.ts\")) {\r\n      devLogWarn(\"warlock.config.ts changed — restart the dev server to apply.\");\r\n    }\r\n\r\n    // Some editors fsync on save without writing — drop no-op changes.\r\n    if (batch.changed.length > 0) {\r\n      batch.changed = await dropNoOpChanges(batch.changed);\r\n    }\r\n\r\n    const total = batch.added.length + batch.changed.length + batch.deleted.length;\r\n    if (total === 0) return;\r\n\r\n    const codeFiles = [...batch.added, ...batch.changed].filter((p) => !isEnvPath(p));\r\n\r\n    try {\r\n      await this.layerExecutor.executeBatchReload(\r\n        codeFiles,\r\n        filesOrchestrator.getFiles(),\r\n        batch.deleted,\r\n        batch.changed,\r\n      );\r\n\r\n      typeGenerator.executeTypingsGenerator([...batch.added, ...batch.changed]);\r\n\r\n      filesOrchestrator.checkHealth(batch);\r\n    } catch (error) {\r\n      devServeLog(colors.redBright(`Failed to execute batch reload: ${error}`));\r\n    }\r\n  }\r\n\r\n  public async shutdown(): Promise<void> {\r\n    if (!this.running) return;\r\n    devServeLog(colors.redBright(\"Shutting down Development Server...\"));\r\n    this.running = false;\r\n    await connectorsManager.shutdown();\r\n    devServeLog(colors.greenBright(\"Development Server stopped\"));\r\n  }\r\n\r\n  public isRunning(): boolean {\r\n    return this.running;\r\n  }\r\n}\r\n\r\nasync function dropNoOpChanges(changedPaths: string[]): Promise<string[]> {\r\n  const kept = await Promise.all(\r\n    changedPaths.map(async (relativePath) => {\r\n      if (isEnvPath(relativePath)) return relativePath;\r\n\r\n      const file = filesOrchestrator.files.get(relativePath);\r\n      if (!file) return null;\r\n\r\n      const content = await getFileAsync(file.absolutePath);\r\n      if (content.trim() === file.source) return null;\r\n\r\n      file.source = content;\r\n      return relativePath;\r\n    }),\r\n  );\r\n\r\n  return kept.filter((p): p is string => p !== null);\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\nfunction parseDuration(ms: number): string {\r\n  if (ms < 1000) return `${ms.toFixed(2)}ms`;\r\n  if (ms > 60_000) return `${(ms / 60_000).toFixed(2)}m`;\r\n  return `${(ms / 1000).toFixed(2)}s`;\r\n}\r\n"],"mappings":"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"}

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

@@ -1 +0,0 @@
-export { };

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

@@ -1 +0,0 @@
-export { };

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

@@ -1,114 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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/hook-thread.d.mts

@@ -1,48 +0,0 @@
-import { TranspileInit, load } from "./load-hook.mjs";
-import { resolve } from "./resolve-hook.mjs";
-import { MessagePort } from "node:worker_threads";
-
-//#region ../../@warlock.js/core/src/dev-server/loader/hook-thread.d.ts
-type InitializeData = {
-  port: MessagePort;
-  srcRoot: string; /** Transpile config (always present — esbuild transpile is unconditional). */
-  transpile: TranspileInit;
-};
-/**
- * ESM loader hook entry-point.
- *
- * Node's `module.register()` runs this file in a dedicated worker thread.
- * The three exported functions (`initialize`, `resolve`, `load`) are the
- * official hook lifecycle callbacks:
- *
- * - `initialize` — runs once when the hook worker starts; receives the data
- *   passed as `{ data }` to `module.register()`. We use it to configure the
- *   source-root filter and to wire the `MessageChannel` port that the main
- *   thread uses to push version-bump notifications.
- *
- * - `resolve` — intercepts every `import` specifier resolution. The
- *   framework's own resolver handles tsconfig `paths` + TS extension/index
- *   probing; npm/`node:` fall through to Node default. Stamps a `?v=<N>`
- *   version token onto tracked `src/` source-file URLs.
- *
- * - `load` — transpiles every `.ts`/`.tsx` with esbuild (content-hash
- *   cached); non-TypeScript falls through to the Node default loader.
- *
- * @example
- * // Main thread (register-loader.ts):
- * const { port1, port2 } = new MessageChannel();
- * module.register(hookBundleUrl, import.meta.url, {
- *   data: { port: port2, srcRoot: "/abs/path/to/src" },
- *   transferList: [port2],
- * });
- * // File watcher later:
- * port1.postMessage({ type: "bump", absolutePath: "/abs/path/to/user.model.ts" });
- */
-declare function initialize({
-  port,
-  srcRoot,
-  transpile
-}: InitializeData): void;
-//#endregion
-export { initialize, load, resolve };
-//# sourceMappingURL=hook-thread.d.mts.map

package/esm/dev-server/loader/hook-thread.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hook-thread.d.mts","names":[],"sources":["../../../../../../../@warlock.js/core/src/dev-server/loader/hook-thread.ts"],"mappings":";;;;;KAKK,cAAA;EACH,IAAA,EAAM,WAAA;EACN,OAAA,UAFiB;EAIjB,SAAA,EAAW,aAAa;AAAA;;;;;;;AAAA;AAiC1B;;;;;;;;;;;;;;;;;AAAuE;;;;;;iBAAvD,UAAA,CAAA;EAAa,IAAA;EAAM,OAAA;EAAS;AAAA,GAAa,cAAA"}

package/esm/dev-server/loader/hook-thread.mjs

@@ -1,47 +0,0 @@
-import { configureTranspile, load } from "./load-hook.mjs";
-import { bumpVersion } from "./version-registry.mjs";
-import { resolve, setSrcRoot } from "./resolve-hook.mjs";
-
-//#region ../../@warlock.js/core/src/dev-server/loader/hook-thread.ts
-/**
-* ESM loader hook entry-point.
-*
-* Node's `module.register()` runs this file in a dedicated worker thread.
-* The three exported functions (`initialize`, `resolve`, `load`) are the
-* official hook lifecycle callbacks:
-*
-* - `initialize` — runs once when the hook worker starts; receives the data
-*   passed as `{ data }` to `module.register()`. We use it to configure the
-*   source-root filter and to wire the `MessageChannel` port that the main
-*   thread uses to push version-bump notifications.
-*
-* - `resolve` — intercepts every `import` specifier resolution. The
-*   framework's own resolver handles tsconfig `paths` + TS extension/index
-*   probing; npm/`node:` fall through to Node default. Stamps a `?v=<N>`
-*   version token onto tracked `src/` source-file URLs.
-*
-* - `load` — transpiles every `.ts`/`.tsx` with esbuild (content-hash
-*   cached); non-TypeScript falls through to the Node default loader.
-*
-* @example
-* // Main thread (register-loader.ts):
-* const { port1, port2 } = new MessageChannel();
-* module.register(hookBundleUrl, import.meta.url, {
-*   data: { port: port2, srcRoot: "/abs/path/to/src" },
-*   transferList: [port2],
-* });
-* // File watcher later:
-* port1.postMessage({ type: "bump", absolutePath: "/abs/path/to/user.model.ts" });
-*/
-function initialize({ port, srcRoot, transpile }) {
-	setSrcRoot(srcRoot);
-	configureTranspile(transpile);
-	port.on("message", ({ type, absolutePath }) => {
-		if (type === "bump") bumpVersion(absolutePath);
-		else if (type === "sync") port.postMessage({ type: "sync-ack" });
-	});
-}
-
-//#endregion
-export { initialize, load, resolve };
-//# sourceMappingURL=hook-thread.mjs.map

package/esm/dev-server/loader/hook-thread.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"hook-thread.mjs","names":[],"sources":["../../../../../../../@warlock.js/core/src/dev-server/loader/hook-thread.ts"],"sourcesContent":["import type { MessagePort } from \"node:worker_threads\";\nimport { configureTranspile, load, type TranspileInit } from \"./load-hook.js\";\nimport { resolve, setSrcRoot } from \"./resolve-hook.js\";\nimport { bumpVersion } from \"./version-registry.js\";\n\ntype InitializeData = {\n  port: MessagePort;\n  srcRoot: string;\n  /** Transpile config (always present — esbuild transpile is unconditional). */\n  transpile: TranspileInit;\n};\n\n/**\n * ESM loader hook entry-point.\n *\n * Node's `module.register()` runs this file in a dedicated worker thread.\n * The three exported functions (`initialize`, `resolve`, `load`) are the\n * official hook lifecycle callbacks:\n *\n * - `initialize` — runs once when the hook worker starts; receives the data\n *   passed as `{ data }` to `module.register()`. We use it to configure the\n *   source-root filter and to wire the `MessageChannel` port that the main\n *   thread uses to push version-bump notifications.\n *\n * - `resolve` — intercepts every `import` specifier resolution. The\n *   framework's own resolver handles tsconfig `paths` + TS extension/index\n *   probing; npm/`node:` fall through to Node default. Stamps a `?v=<N>`\n *   version token onto tracked `src/` source-file URLs.\n *\n * - `load` — transpiles every `.ts`/`.tsx` with esbuild (content-hash\n *   cached); non-TypeScript falls through to the Node default loader.\n *\n * @example\n * // Main thread (register-loader.ts):\n * const { port1, port2 } = new MessageChannel();\n * module.register(hookBundleUrl, import.meta.url, {\n *   data: { port: port2, srcRoot: \"/abs/path/to/src\" },\n *   transferList: [port2],\n * });\n * // File watcher later:\n * port1.postMessage({ type: \"bump\", absolutePath: \"/abs/path/to/user.model.ts\" });\n */\nexport function initialize({ port, srcRoot, transpile }: InitializeData): void {\n  setSrcRoot(srcRoot);\n  configureTranspile(transpile);\n\n  port.on(\"message\", ({ type, absolutePath }: { type: string; absolutePath: string }) => {\n    if (type === \"bump\") {\n      bumpVersion(absolutePath);\n    } else if (type === \"sync\") {\n      port.postMessage({ type: \"sync-ack\" });\n    }\n  });\n}\n\nexport { load, resolve };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,SAAgB,WAAW,EAAE,MAAM,SAAS,aAAmC;CAC7E,WAAW,OAAO;CAClB,mBAAmB,SAAS;CAE5B,KAAK,GAAG,YAAY,EAAE,MAAM,mBAA2D;EACrF,IAAI,SAAS,QACX,YAAY,YAAY;OACnB,IAAI,SAAS,QAClB,KAAK,YAAY,EAAE,MAAM,WAAW,CAAC;CAEzC,CAAC;AACH"}

package/esm/dev-server/loader/load-hook.d.mts

@@ -1,58 +0,0 @@
-//#region ../../@warlock.js/core/src/dev-server/loader/load-hook.d.ts
-type LoadContext = {
-  format?: string;
-  importAttributes?: Record<string, string>;
-};
-type LoadResult = {
-  format: string;
-  source: string | Buffer;
-  shortCircuit?: boolean;
-};
-type NextLoad = (url: string, context?: LoadContext) => Promise<LoadResult>;
-/**
- * Everything the transpile path needs, computed once on the main thread and
- * shipped into the hook worker via `initialize()`. Always present — esbuild
- * transpile is unconditional now (tsx is no longer in the TS path).
- */
-type TranspileInit = {
-  /** Absolute `.warlock/transpile` directory. */cacheDir: string; /** Source-content key salt: esbuild version + epoch + tsconfig blob. */
-  fingerprint: string; /** esbuild `target` (e.g. `"node22"` — must match the prod builder). */
-  target: string; /** JSON string of `{ compilerOptions }` handed to esbuild as tsconfigRaw. */
-  tsconfigRaw: string;
-  /**
-   * Debug-only: name cache files `<slug>.<hash>.js` and append a trailing
-   * `// @source <path>` marker so entries are eyeball-identifiable. Off by
-   * default (opaque `<hash>.js`). Cosmetic — never affects keys or lookup.
-   */
-  debugNames: boolean;
-};
-/**
- * ESM loader `load()` hook.
- *
- * Owns the transpile for **every** TypeScript file — project `src/`,
- * `@warlock.js/*` framework source, and `warlock.config.ts` alike. There
- * is no tsx in the TypeScript path any more: we read the source, key it by
- * a content hash + options fingerprint, serve the cached JS on a hit, and
- * otherwise transform it with esbuild directly and persist. Non-TypeScript
- * URLs (npm `.js`/`.cjs`/`.mjs`, `node:` builtins, JSON) are not ours —
- * they fall through to the next loader (Node's default).
- *
- * The `?v=<N>` query drives Node's module identity (HMR) for `src/` files
- * and is **never** part of the cache key — the cache is keyed purely by
- * source content, so the two mechanisms are fully orthogonal. Framework
- * and config `.ts` carry no `?v` (no HMR) but are transpiled and cached
- * exactly the same way.
- *
- * The source map esbuild emits is inline base64 with `sourcefile` set to
- * the clean absolute `.ts` path, so V8 (run with source maps enabled)
- * reports stack frames at the original TypeScript location.
- *
- * @example
- * // load("file:///src/user.model.ts?v=3")  → esbuild transpile + cache
- * // load("file:///@warlock.js/core/src/x.ts") → esbuild transpile + cache
- * // load("file:///node_modules/ms/index.js")  → nextLoad (Node default)
- */
-declare function load(url: string, context: LoadContext, nextLoad: NextLoad): Promise<LoadResult>;
-//#endregion
-export { TranspileInit, load };
-//# sourceMappingURL=load-hook.d.mts.map

package/esm/dev-server/loader/load-hook.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"load-hook.d.mts","names":[],"sources":["../../../../../../../@warlock.js/core/src/dev-server/loader/load-hook.ts"],"mappings":";KAMK,WAAA;EACH,MAAA;EACA,gBAAA,GAAmB,MAAM;AAAA;AAAA,KAGtB,UAAA;EACH,MAAA;EACA,MAAA,WAAiB,MAAM;EACvB,YAAA;AAAA;AAAA,KAGG,QAAA,IAAY,GAAA,UAAa,OAAA,GAAU,WAAA,KAAgB,OAAA,CAAQ,UAAA;AATrC;;;;;AAAA,KAgBf,aAAA;EAXO,+CAajB,QAAA,UAZY;EAcZ,WAAA,UAXG;EAaH,MAAA;EAEA,WAAA;EAf8D;;;;;EAqB9D,UAAA;AAAA;;;;;;;;;AAAU;AAqDZ;;;;;;;;;;;;;;;;;iBAAsB,IAAA,CACpB,GAAA,UACA,OAAA,EAAS,WAAA,EACT,QAAA,EAAU,QAAA,GACT,OAAA,CAAQ,UAAA"}

package/esm/dev-server/loader/load-hook.mjs

@@ -1,86 +0,0 @@
-import { TranspileCache, cacheKey } from "./transpile-cache.mjs";
-import { sourceSlug } from "./source-slug.mjs";
-import { transformSync } from "esbuild";
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-
-//#region ../../@warlock.js/core/src/dev-server/loader/load-hook.ts
-const VERSION_QUERY = /\?v=\d+$/;
-const TS_FILE = /\.(ts|tsx|mts|cts)$/;
-let transpile;
-let cache;
-/**
-* Called once from the hook worker's `initialize()`. Wires the persisted
-* transpile cache and runs one opportunistic GC pass at boot — cheap, off
-* the hot path, single directory scan.
-*/
-function configureTranspile(init) {
-	transpile = init;
-	cache = new TranspileCache(init.cacheDir);
-	cache.gc({
-		maxBytes: 256 * 1024 * 1024,
-		maxAgeMs: 336 * 60 * 60 * 1e3
-	});
-}
-/**
-* ESM loader `load()` hook.
-*
-* Owns the transpile for **every** TypeScript file — project `src/`,
-* `@warlock.js/*` framework source, and `warlock.config.ts` alike. There
-* is no tsx in the TypeScript path any more: we read the source, key it by
-* a content hash + options fingerprint, serve the cached JS on a hit, and
-* otherwise transform it with esbuild directly and persist. Non-TypeScript
-* URLs (npm `.js`/`.cjs`/`.mjs`, `node:` builtins, JSON) are not ours —
-* they fall through to the next loader (Node's default).
-*
-* The `?v=<N>` query drives Node's module identity (HMR) for `src/` files
-* and is **never** part of the cache key — the cache is keyed purely by
-* source content, so the two mechanisms are fully orthogonal. Framework
-* and config `.ts` carry no `?v` (no HMR) but are transpiled and cached
-* exactly the same way.
-*
-* The source map esbuild emits is inline base64 with `sourcefile` set to
-* the clean absolute `.ts` path, so V8 (run with source maps enabled)
-* reports stack frames at the original TypeScript location.
-*
-* @example
-* // load("file:///src/user.model.ts?v=3")  → esbuild transpile + cache
-* // load("file:///@warlock.js/core/src/x.ts") → esbuild transpile + cache
-* // load("file:///node_modules/ms/index.js")  → nextLoad (Node default)
-*/
-async function load(url, context, nextLoad) {
-	const cleanUrl = url.replace(VERSION_QUERY, "");
-	if (!TS_FILE.test(cleanUrl)) return nextLoad(url, context);
-	const absolutePath = fileURLToPath(cleanUrl);
-	const source = readFileSync(absolutePath, "utf8");
-	const key = cacheKey(source, transpile.fingerprint);
-	const label = transpile.debugNames ? sourceSlug(absolutePath) : void 0;
-	const hit = cache.get(key, label);
-	if (hit) return {
-		format: "module",
-		source: hit.code,
-		shortCircuit: true
-	};
-	const result = transformSync(source, {
-		loader: absolutePath.endsWith(".tsx") ? "tsx" : "ts",
-		format: "esm",
-		target: transpile.target,
-		sourcefile: absolutePath,
-		sourcemap: "inline",
-		tsconfigRaw: transpile.tsconfigRaw
-	});
-	const code = label ? `${result.code}\n// @source ${absolutePath}\n` : result.code;
-	cache.put(key, {
-		code,
-		map: ""
-	}, label);
-	return {
-		format: "module",
-		source: code,
-		shortCircuit: true
-	};
-}
-
-//#endregion
-export { configureTranspile, load };
-//# sourceMappingURL=load-hook.mjs.map

package/esm/dev-server/loader/load-hook.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"load-hook.mjs","names":[],"sources":["../../../../../../../@warlock.js/core/src/dev-server/loader/load-hook.ts"],"sourcesContent":["import { transformSync } from \"esbuild\";\nimport { readFileSync } from \"node:fs\";\nimport { fileURLToPath } from \"node:url\";\nimport { sourceSlug } from \"./source-slug.js\";\nimport { cacheKey, TranspileCache } from \"./transpile-cache.js\";\n\ntype LoadContext = {\n  format?: string;\n  importAttributes?: Record<string, string>;\n};\n\ntype LoadResult = {\n  format: string;\n  source: string | Buffer;\n  shortCircuit?: boolean;\n};\n\ntype NextLoad = (url: string, context?: LoadContext) => Promise<LoadResult>;\n\n/**\n * Everything the transpile path needs, computed once on the main thread and\n * shipped into the hook worker via `initialize()`. Always present — esbuild\n * transpile is unconditional now (tsx is no longer in the TS path).\n */\nexport type TranspileInit = {\n  /** Absolute `.warlock/transpile` directory. */\n  cacheDir: string;\n  /** Source-content key salt: esbuild version + epoch + tsconfig blob. */\n  fingerprint: string;\n  /** esbuild `target` (e.g. `\"node22\"` — must match the prod builder). */\n  target: string;\n  /** JSON string of `{ compilerOptions }` handed to esbuild as tsconfigRaw. */\n  tsconfigRaw: string;\n  /**\n   * Debug-only: name cache files `<slug>.<hash>.js` and append a trailing\n   * `// @source <path>` marker so entries are eyeball-identifiable. Off by\n   * default (opaque `<hash>.js`). Cosmetic — never affects keys or lookup.\n   */\n  debugNames: boolean;\n};\n\nconst VERSION_QUERY = /\\?v=\\d+$/;\nconst TS_FILE = /\\.(ts|tsx|mts|cts)$/;\n\nlet transpile: TranspileInit;\nlet cache: TranspileCache;\n\n/**\n * Called once from the hook worker's `initialize()`. Wires the persisted\n * transpile cache and runs one opportunistic GC pass at boot — cheap, off\n * the hot path, single directory scan.\n */\nexport function configureTranspile(init: TranspileInit): void {\n  transpile = init;\n  cache = new TranspileCache(init.cacheDir);\n\n  // Boot-time eviction so the cache can't grow unbounded across weeks of\n  // dev. Bounds are generous; correctness never depends on GC (content\n  // hashing already guarantees that) — this is purely disk hygiene.\n  cache.gc({\n    maxBytes: 256 * 1024 * 1024,\n    maxAgeMs: 14 * 24 * 60 * 60 * 1000,\n  });\n}\n\n/**\n * ESM loader `load()` hook.\n *\n * Owns the transpile for **every** TypeScript file — project `src/`,\n * `@warlock.js/*` framework source, and `warlock.config.ts` alike. There\n * is no tsx in the TypeScript path any more: we read the source, key it by\n * a content hash + options fingerprint, serve the cached JS on a hit, and\n * otherwise transform it with esbuild directly and persist. Non-TypeScript\n * URLs (npm `.js`/`.cjs`/`.mjs`, `node:` builtins, JSON) are not ours —\n * they fall through to the next loader (Node's default).\n *\n * The `?v=<N>` query drives Node's module identity (HMR) for `src/` files\n * and is **never** part of the cache key — the cache is keyed purely by\n * source content, so the two mechanisms are fully orthogonal. Framework\n * and config `.ts` carry no `?v` (no HMR) but are transpiled and cached\n * exactly the same way.\n *\n * The source map esbuild emits is inline base64 with `sourcefile` set to\n * the clean absolute `.ts` path, so V8 (run with source maps enabled)\n * reports stack frames at the original TypeScript location.\n *\n * @example\n * // load(\"file:///src/user.model.ts?v=3\")  → esbuild transpile + cache\n * // load(\"file:///@warlock.js/core/src/x.ts\") → esbuild transpile + cache\n * // load(\"file:///node_modules/ms/index.js\")  → nextLoad (Node default)\n */\nexport async function load(\n  url: string,\n  context: LoadContext,\n  nextLoad: NextLoad,\n): Promise<LoadResult> {\n  const cleanUrl = url.replace(VERSION_QUERY, \"\");\n\n  // Not TypeScript → not ours. npm packages, node: builtins, JSON, etc.\n  if (!TS_FILE.test(cleanUrl)) {\n    return nextLoad(url, context);\n  }\n\n  const absolutePath = fileURLToPath(cleanUrl);\n  const source = readFileSync(absolutePath, \"utf8\");\n  const key = cacheKey(source, transpile.fingerprint);\n\n  // Cosmetic filename label; undefined keeps opaque <hash>.js names.\n  const label = transpile.debugNames ? sourceSlug(absolutePath) : undefined;\n\n  const hit = cache.get(key, label);\n  if (hit) {\n    return { format: \"module\", source: hit.code, shortCircuit: true };\n  }\n\n  const loader = absolutePath.endsWith(\".tsx\") ? \"tsx\" : \"ts\";\n\n  const result = transformSync(source, {\n    loader,\n    format: \"esm\",\n    target: transpile.target,\n    sourcefile: absolutePath,\n    // Inline base64 map, self-contained (sourcesContent on by default), so\n    // it survives the ?v=N URL with no extra resolution step.\n    sourcemap: \"inline\",\n    tsconfigRaw: transpile.tsconfigRaw,\n  });\n\n  // result.code already carries the inline //# sourceMappingURL. The\n  // marker goes AFTER that line: a trailing comment can't shift earlier\n  // generated lines, so the inline map (and therefore stack-frame line\n  // numbers) stays exact. A leading marker would desync it by one line.\n  const code = label\n    ? `${result.code}\\n// @source ${absolutePath}\\n`\n    : result.code;\n\n  cache.put(key, { code, map: \"\" }, label);\n\n  return { format: \"module\", source: code, shortCircuit: true };\n}\n"],"mappings":";;;;;;;AAyCA,MAAM,gBAAgB;AACtB,MAAM,UAAU;AAEhB,IAAI;AACJ,IAAI;;;;;;AAOJ,SAAgB,mBAAmB,MAA2B;CAC5D,YAAY;CACZ,QAAQ,IAAI,eAAe,KAAK,QAAQ;CAKxC,MAAM,GAAG;EACP,UAAU,MAAM,OAAO;EACvB,UAAU,MAAU,KAAK,KAAK;CAChC,CAAC;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,eAAsB,KACpB,KACA,SACA,UACqB;CACrB,MAAM,WAAW,IAAI,QAAQ,eAAe,EAAE;CAG9C,IAAI,CAAC,QAAQ,KAAK,QAAQ,GACxB,OAAO,SAAS,KAAK,OAAO;CAG9B,MAAM,eAAe,cAAc,QAAQ;CAC3C,MAAM,SAAS,aAAa,cAAc,MAAM;CAChD,MAAM,MAAM,SAAS,QAAQ,UAAU,WAAW;CAGlD,MAAM,QAAQ,UAAU,aAAa,WAAW,YAAY,IAAI;CAEhE,MAAM,MAAM,MAAM,IAAI,KAAK,KAAK;CAChC,IAAI,KACF,OAAO;EAAE,QAAQ;EAAU,QAAQ,IAAI;EAAM,cAAc;CAAK;CAKlE,MAAM,SAAS,cAAc,QAAQ;EACnC,QAHa,aAAa,SAAS,MAAM,IAAI,QAAQ;EAIrD,QAAQ;EACR,QAAQ,UAAU;EAClB,YAAY;EAGZ,WAAW;EACX,aAAa,UAAU;CACzB,CAAC;CAMD,MAAM,OAAO,QACT,GAAG,OAAO,KAAK,eAAe,aAAa,MAC3C,OAAO;CAEX,MAAM,IAAI,KAAK;EAAE;EAAM,KAAK;CAAG,GAAG,KAAK;CAEvC,OAAO;EAAE,QAAQ;EAAU,QAAQ;EAAM,cAAc;CAAK;AAC9D"}

package/esm/dev-server/loader/own-resolver.mjs

@@ -1,69 +0,0 @@
-import { URL, fileURLToPath, pathToFileURL } from "node:url";
-
-//#region ../../@warlock.js/core/src/dev-server/loader/own-resolver.ts
-/**
-* Extension/`index` probing for one candidate base path, mirroring tsx's
-* TypeScript-aware order:
-*
-* 1. exact (if it already has a real extension that exists)
-* 2. `.js`/`.jsx`/`.mjs`/`.cjs` specifier → the TS source it compiles from
-*    (`.ts`/`.tsx`) — the standard "import the .js, ship the .ts" ESM style
-* 3. append `.ts`, `.tsx`, `.js`, `.jsx`, `.json`
-* 4. directory index: `<dir>/index.{ts,tsx,js,jsx}`
-*
-* Returns the resolved absolute path, or `null` if nothing exists.
-*/
-function probeFile(basePath, fileExists) {
-	const jsRewrite = basePath.match(/\.(js|jsx|mjs|cjs)$/);
-	if (jsRewrite) {
-		const stem = basePath.slice(0, -jsRewrite[0].length);
-		for (const ext of [".ts", ".tsx"]) if (fileExists(stem + ext)) return stem + ext;
-	}
-	if (/\.[a-z]+$/i.test(basePath) && fileExists(basePath)) return basePath;
-	for (const ext of [
-		".ts",
-		".tsx",
-		".js",
-		".jsx",
-		".json"
-	]) if (fileExists(basePath + ext)) return basePath + ext;
-	for (const ext of [
-		".ts",
-		".tsx",
-		".js",
-		".jsx"
-	]) {
-		const candidate = `${basePath}/index${ext}`;
-		if (fileExists(candidate)) return candidate;
-	}
-	return null;
-}
-function isRelative(specifier) {
-	return specifier.startsWith("./") || specifier.startsWith("../");
-}
-/**
-* Resolve `specifier` to a `file://` URL we own, or `null` to fall through
-* to the next resolver.
-*
-* @param specifier  - The import specifier.
-* @param parentURL  - Importing module's URL (already `?v=N`-stripped).
-* @param pathsMatcher - `get-tsconfig` paths matcher (alias → candidates).
-* @param fileExists - Existence probe (injected for testing).
-*/
-function ownResolve(specifier, parentURL, pathsMatcher, fileExists) {
-	if (specifier.startsWith("node:") || specifier.startsWith("file:") || specifier.startsWith("data:")) return null;
-	if (isRelative(specifier) || specifier.startsWith("/") || /^[a-zA-Z]:[\\/]/.test(specifier)) {
-		if (!parentURL) return null;
-		const hit = probeFile(fileURLToPath(new URL(specifier, parentURL)).replace(/\\/g, "/"), fileExists);
-		return hit ? pathToFileURL(hit).href : null;
-	}
-	if (pathsMatcher) for (const candidate of pathsMatcher(specifier)) {
-		const hit = probeFile(candidate.replace(/\\/g, "/"), fileExists);
-		if (hit) return pathToFileURL(hit).href;
-	}
-	return null;
-}
-
-//#endregion
-export { ownResolve };
-//# sourceMappingURL=own-resolver.mjs.map