@warlock.js/core 4.8.2 → 4.9.1

package/esm/warlock-config/warlock-config.manager.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"warlock-config.manager.d.mts","names":[],"sources":["../../../../../../../@warlock.js/core/src/warlock-config/warlock-config.manager.ts"],"mappings":";;;;;AAgBA;;;;AAAwD;AAaxD;iBAbgB,yBAAA,CAA0B,KAAc;;;;;;;cAa3C,oBAAA;EAsHR;;;EAAA,QAlHK,MAAA;EAsIS;;;EAAA,QAjIT,OAAA;EAkIL;;;;;EA3HU,IAAA,IAAQ,OAAA,CAAQ,aAAA;EAPrB;;;;;;EAAA,QAgCM,MAAA;EA0EH;;;;;;;;EAAA,QAtCG,cAAA;EA2DR;;;;;;;;;;;EArBC,GAAA,mBAAsB,aAAA,EAC3B,GAAA,EAAK,GAAA,EACL,YAAA,GAAe,aAAA,CAAc,GAAA,IAC5B,aAAA,CAAc,GAAA;EAsCV;;;;;AAWuB;AAoBhC;;;;EAnDQ,OAAA,mBAA0B,aAAA,EAC9B,GAAA,EAAK,GAAA,EACL,YAAA,GAAe,aAAA,CAAc,GAAA,IAC5B,OAAA,CAAQ,aAAA,CAAc,GAAA;;;;MAQd,QAAA;;;;;;EASJ,MAAA,IAAU,aAAA;;;;EAWJ,MAAA,IAAU,OAAA;AAAA;;;;;;;;;;;;;;cAoBZ,oBAAA,EAAoB,oBAA6B"}
+{"version":3,"file":"warlock-config.manager.d.mts","names":[],"sources":["../../../../../../../core/src/warlock-config/warlock-config.manager.ts"],"mappings":";;;;;AAgBA;;;;AAAwD;AAaxD;iBAbgB,yBAAA,CAA0B,KAAc;;;;;;;cAa3C,oBAAA;EAsHR;;;EAAA,QAlHK,MAAA;EAsIS;;;EAAA,QAjIT,OAAA;EAkIL;;;;;EA3HU,IAAA,IAAQ,OAAA,CAAQ,aAAA;EAPrB;;;;;;EAAA,QAgCM,MAAA;EA0EH;;;;;;;;EAAA,QAtCG,cAAA;EA2DR;;;;;;;;;;;EArBC,GAAA,mBAAsB,aAAA,EAC3B,GAAA,EAAK,GAAA,EACL,YAAA,GAAe,aAAA,CAAc,GAAA,IAC5B,aAAA,CAAc,GAAA;EAsCV;;;;;AAWuB;AAoBhC;;;;EAnDQ,OAAA,mBAA0B,aAAA,EAC9B,GAAA,EAAK,GAAA,EACL,YAAA,GAAe,aAAA,CAAc,GAAA,IAC5B,OAAA,CAAQ,aAAA,CAAc,GAAA;;;;MAQd,QAAA;;;;;;EASJ,MAAA,IAAU,aAAA;;;;EAWJ,MAAA,IAAU,OAAA;AAAA;;;;;;;;;;;;;;cAoBZ,oBAAA,EAAoB,oBAA6B"}

package/esm/warlock-config/warlock-config.manager.mjs

@@ -6,7 +6,7 @@ import { fileExistsAsync } from "@warlock.js/fs";
 import { readFile, unlink, writeFile } from "node:fs/promises";
 import { pathToFileURL } from "url";
 
-//#region ../@warlock.js/core/src/warlock-config/warlock-config.manager.ts
+//#region ../core/src/warlock-config/warlock-config.manager.ts
 /**
 * True when `error` is Node's "this runtime can't import a `.ts` file" error.
 *

package/esm/warlock-config/warlock-config.manager.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"warlock-config.manager.mjs","names":[],"sources":["../../../../../../../@warlock.js/core/src/warlock-config/warlock-config.manager.ts"],"sourcesContent":["import { fileExistsAsync } from \"@warlock.js/fs\";\r\nimport { get } from \"@mongez/reinforcements\";\r\nimport { readFile, unlink, writeFile } from \"node:fs/promises\";\r\nimport { pathToFileURL } from \"url\";\r\nimport { devLogWarn } from \"../dev-server/dev-logger\";\r\nimport { rootPath } from \"../utils\";\r\nimport { WarlockConfig } from \"./types\";\r\n\r\n/**\r\n * True when `error` is Node's \"this runtime can't import a `.ts` file\" error.\r\n *\r\n * Node only executes TypeScript natively from v22.18 / v23.6 onward (earlier\r\n * 22.x needs `--experimental-strip-types`). On older runtimes a bare\r\n * `import(\"warlock.config.ts\")` throws `ERR_UNKNOWN_FILE_EXTENSION` — which is\r\n * the signal to fall back to transpiling the config ourselves.\r\n */\r\nexport function isUnknownTsExtensionError(error: unknown): boolean {\r\n  return (\r\n    (error as { code?: string })?.code === \"ERR_UNKNOWN_FILE_EXTENSION\" ||\r\n    /Unknown file extension \"\\.tsx?\"/.test(String((error as Error)?.message))\r\n  );\r\n}\r\n\r\n/**\r\n * Warlock Config Manager\r\n *\r\n * Manages lazy loading of the pre-compiled warlock.config.js file\r\n * from the .warlock/cache directory.\r\n */\r\nexport class WarlockConfigManager {\r\n  /**\r\n   * Cached config instance\r\n   */\r\n  private config?: WarlockConfig;\r\n\r\n  /**\r\n   * Loading promise to prevent duplicate loads\r\n   */\r\n  private loading?: Promise<WarlockConfig | undefined>;\r\n\r\n  /**\r\n   * Load warlock.config.js (cached after first load)\r\n   *\r\n   * @returns The resolved Warlock configuration\r\n   */\r\n  public async load(): Promise<WarlockConfig | undefined> {\r\n    // Already loaded\r\n    if (this.config) {\r\n      return this.config;\r\n    }\r\n\r\n    // Currently loading (prevent duplicate loads)\r\n    if (this.loading) {\r\n      return this.loading;\r\n    }\r\n\r\n    // Start loading\r\n    this.loading = this.doLoad();\r\n    this.config = await this.loading;\r\n    this.loading = undefined;\r\n\r\n    return this.config;\r\n  }\r\n\r\n  /**\r\n   * Internal load implementation\r\n   *\r\n   * The ESM loader hook transpiles `warlock.config.ts` on import — no\r\n   * separate compile-to-disk step is needed.\r\n   */\r\n  private async doLoad(): Promise<WarlockConfig | undefined> {\r\n    const configPath = rootPath(\"warlock.config.ts\");\r\n\r\n    if (!(await fileExistsAsync(configPath))) {\r\n      devLogWarn(\r\n        \"warlock.config.ts is missing, it's highly recommended to create it, run warlock init to create it\",\r\n      );\r\n      return;\r\n    }\r\n\r\n    try {\r\n      const configModule = await import(pathToFileURL(configPath).href);\r\n      return configModule.default;\r\n    } catch (error) {\r\n      // `dev` registers a TS loader hook, and Node ≥ 22.18 / 23.6 strips types\r\n      // natively — in both cases the direct import above works. But `build` /\r\n      // `start` register no hook, so on an older Node the import throws\r\n      // ERR_UNKNOWN_FILE_EXTENSION. Transpile the config with esbuild ourselves\r\n      // so config loading is Node-version-independent rather than relying on an\r\n      // experimental runtime feature.\r\n      if (isUnknownTsExtensionError(error)) {\r\n        return await this.loadViaEsbuild(configPath);\r\n      }\r\n\r\n      throw new Error(`Failed to load warlock.config.ts: ${error}`);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Fallback config loader for runtimes without native TypeScript support.\r\n   *\r\n   * Transpiles `warlock.config.ts` with esbuild (already a core dependency),\r\n   * writes the result as a sibling `.mjs` — so the config's own imports (bare\r\n   * `@warlock.js/*` and any relative paths) resolve exactly as they would from\r\n   * the original location — imports it, then removes the temp file.\r\n   */\r\n  private async loadViaEsbuild(configPath: string): Promise<WarlockConfig | undefined> {\r\n    const { transformSync } = await import(\"esbuild\");\r\n    const source = await readFile(configPath, \"utf8\");\r\n\r\n    const { code } = transformSync(source, {\r\n      loader: \"ts\",\r\n      format: \"esm\",\r\n      target: `node${process.versions.node.split(\".\")[0]}`,\r\n      sourcefile: configPath,\r\n    });\r\n\r\n    // Unique sibling name so concurrent processes never clobber each other.\r\n    const compiledPath = configPath.replace(\r\n      /warlock\\.config\\.ts$/,\r\n      `.warlock.config.${process.pid}.mjs`,\r\n    );\r\n\r\n    await writeFile(compiledPath, code, \"utf8\");\r\n\r\n    try {\r\n      const configModule = await import(pathToFileURL(compiledPath).href);\r\n      return configModule.default;\r\n    } finally {\r\n      await unlink(compiledPath).catch(() => {});\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get config value by key (dot notation supported)\r\n   *\r\n   * @example\r\n   * config.get(\"server.port\") // Returns 3000\r\n   * config.get(\"cli.commands\") // Returns array of commands\r\n   *\r\n   * @param key - Config key (supports dot notation), autocompletes for first level only\r\n   * @returns The config value\r\n   * @throws Error if config is not loaded\r\n   */\r\n  public get<Key extends keyof WarlockConfig>(\r\n    key: Key,\r\n    defaultValue?: WarlockConfig[Key],\r\n  ): WarlockConfig[Key] {\r\n    if (!this.config) {\r\n      throw new Error(\"WarlockConfig not loaded. Call load() first or use lazyGet().\");\r\n    }\r\n\r\n    return get(this.config, key as string, defaultValue);\r\n  }\r\n\r\n  /**\r\n   * Lazy get - loads config if not already loaded\r\n   *\r\n   * @example\r\n   * const port = await config.lazyGet(\"server\");\r\n   *\r\n   * @param key - Config key (supports dot notation), autocompletes for first level only\r\n   * @param defaultValue - Default value if config key is undefined\r\n   * @returns The config value\r\n   */\r\n  async lazyGet<Key extends keyof WarlockConfig>(\r\n    key: Key,\r\n    defaultValue?: WarlockConfig[Key],\r\n  ): Promise<WarlockConfig[Key]> {\r\n    await this.load();\r\n    return this.get(key, defaultValue);\r\n  }\r\n\r\n  /**\r\n   * Check if config is loaded\r\n   */\r\n  public get isLoaded(): boolean {\r\n    return this.config !== undefined;\r\n  }\r\n\r\n  /**\r\n   * Get the entire config object\r\n   *\r\n   * @throws Error if config is not loaded\r\n   */\r\n  public getAll(): WarlockConfig {\r\n    if (!this.config) {\r\n      throw new Error(\"WarlockConfig not loaded. Call load() first or use lazyGet().\");\r\n    }\r\n\r\n    return this.config;\r\n  }\r\n\r\n  /**\r\n   * Reload config (useful for HMR/development)\r\n   */\r\n  public async reload(): Promise<void> {\r\n    this.config = undefined;\r\n    this.loading = undefined;\r\n    await this.load();\r\n  }\r\n}\r\n\r\n/**\r\n * Exported singleton instance\r\n *\r\n * @example\r\n * import { warlockConfig } from \"@warlock.js/core\";\r\n *\r\n * // Lazy load and get value\r\n * const port = await warlockConfig.lazyGet(\"server.port\");\r\n *\r\n * // Or load first, then get\r\n * await warlockConfig.load();\r\n * const commands = warlockConfig.get(\"cli.commands\");\r\n */\r\nexport const warlockConfigManager = new WarlockConfigManager();\r\n"],"mappings":";;;;;;;;;;;;;;;;;AAgBA,SAAgB,0BAA0B,OAAyB;CACjE,OACG,OAA6B,SAAS,gCACvC,kCAAkC,KAAK,OAAQ,OAAiB,OAAO,CAAC;AAE5E;;;;;;;AAQA,IAAa,uBAAb,MAAkC;;;;;;CAgBhC,MAAa,OAA2C;EAEtD,IAAI,KAAK,QACP,OAAO,KAAK;EAId,IAAI,KAAK,SACP,OAAO,KAAK;EAId,KAAK,UAAU,KAAK,OAAO;EAC3B,KAAK,SAAS,MAAM,KAAK;EACzB,KAAK,UAAU;EAEf,OAAO,KAAK;CACd;;;;;;;CAQA,MAAc,SAA6C;EACzD,MAAM,aAAa,SAAS,mBAAmB;EAE/C,IAAI,CAAE,MAAM,gBAAgB,UAAU,GAAI;GACxC,WACE,mGACF;GACA;EACF;EAEA,IAAI;GAEF,QAAO,MADoB,OAAO,cAAc,UAAU,CAAC,CAAC,MACzC,CAAC;EACtB,SAAS,OAAO;GAOd,IAAI,0BAA0B,KAAK,GACjC,OAAO,MAAM,KAAK,eAAe,UAAU;GAG7C,MAAM,IAAI,MAAM,qCAAqC,OAAO;EAC9D;CACF;;;;;;;;;CAUA,MAAc,eAAe,YAAwD;EACnF,MAAM,EAAE,kBAAkB,MAAM,OAAO;EAGvC,MAAM,EAAE,SAAS,cAAc,MAFV,SAAS,YAAY,MAAM,GAET;GACrC,QAAQ;GACR,QAAQ;GACR,QAAQ,OAAO,QAAQ,SAAS,KAAK,MAAM,GAAG,CAAC,CAAC;GAChD,YAAY;EACd,CAAC;EAGD,MAAM,eAAe,WAAW,QAC9B,wBACA,mBAAmB,QAAQ,IAAI,KACjC;EAEA,MAAM,UAAU,cAAc,MAAM,MAAM;EAE1C,IAAI;GAEF,QAAO,MADoB,OAAO,cAAc,YAAY,CAAC,CAAC,MAC3C,CAAC;EACtB,UAAU;GACR,MAAM,OAAO,YAAY,CAAC,CAAC,YAAY,CAAC,CAAC;EAC3C;CACF;;;;;;;;;;;;CAaA,AAAO,IACL,KACA,cACoB;EACpB,IAAI,CAAC,KAAK,QACR,MAAM,IAAI,MAAM,+DAA+D;EAGjF,OAAO,IAAI,KAAK,QAAQ,KAAe,YAAY;CACrD;;;;;;;;;;;CAYA,MAAM,QACJ,KACA,cAC6B;EAC7B,MAAM,KAAK,KAAK;EAChB,OAAO,KAAK,IAAI,KAAK,YAAY;CACnC;;;;CAKA,IAAW,WAAoB;EAC7B,OAAO,KAAK,WAAW;CACzB;;;;;;CAOA,AAAO,SAAwB;EAC7B,IAAI,CAAC,KAAK,QACR,MAAM,IAAI,MAAM,+DAA+D;EAGjF,OAAO,KAAK;CACd;;;;CAKA,MAAa,SAAwB;EACnC,KAAK,SAAS;EACd,KAAK,UAAU;EACf,MAAM,KAAK,KAAK;CAClB;AACF;;;;;;;;;;;;;;AAeA,MAAa,uBAAuB,IAAI,qBAAqB"}
+{"version":3,"file":"warlock-config.manager.mjs","names":[],"sources":["../../../../../../../core/src/warlock-config/warlock-config.manager.ts"],"sourcesContent":["import { fileExistsAsync } from \"@warlock.js/fs\";\r\nimport { get } from \"@mongez/reinforcements\";\r\nimport { readFile, unlink, writeFile } from \"node:fs/promises\";\r\nimport { pathToFileURL } from \"url\";\r\nimport { devLogWarn } from \"../dev-server/dev-logger\";\r\nimport { rootPath } from \"../utils\";\r\nimport { WarlockConfig } from \"./types\";\r\n\r\n/**\r\n * True when `error` is Node's \"this runtime can't import a `.ts` file\" error.\r\n *\r\n * Node only executes TypeScript natively from v22.18 / v23.6 onward (earlier\r\n * 22.x needs `--experimental-strip-types`). On older runtimes a bare\r\n * `import(\"warlock.config.ts\")` throws `ERR_UNKNOWN_FILE_EXTENSION` — which is\r\n * the signal to fall back to transpiling the config ourselves.\r\n */\r\nexport function isUnknownTsExtensionError(error: unknown): boolean {\r\n  return (\r\n    (error as { code?: string })?.code === \"ERR_UNKNOWN_FILE_EXTENSION\" ||\r\n    /Unknown file extension \"\\.tsx?\"/.test(String((error as Error)?.message))\r\n  );\r\n}\r\n\r\n/**\r\n * Warlock Config Manager\r\n *\r\n * Manages lazy loading of the pre-compiled warlock.config.js file\r\n * from the .warlock/cache directory.\r\n */\r\nexport class WarlockConfigManager {\r\n  /**\r\n   * Cached config instance\r\n   */\r\n  private config?: WarlockConfig;\r\n\r\n  /**\r\n   * Loading promise to prevent duplicate loads\r\n   */\r\n  private loading?: Promise<WarlockConfig | undefined>;\r\n\r\n  /**\r\n   * Load warlock.config.js (cached after first load)\r\n   *\r\n   * @returns The resolved Warlock configuration\r\n   */\r\n  public async load(): Promise<WarlockConfig | undefined> {\r\n    // Already loaded\r\n    if (this.config) {\r\n      return this.config;\r\n    }\r\n\r\n    // Currently loading (prevent duplicate loads)\r\n    if (this.loading) {\r\n      return this.loading;\r\n    }\r\n\r\n    // Start loading\r\n    this.loading = this.doLoad();\r\n    this.config = await this.loading;\r\n    this.loading = undefined;\r\n\r\n    return this.config;\r\n  }\r\n\r\n  /**\r\n   * Internal load implementation\r\n   *\r\n   * The ESM loader hook transpiles `warlock.config.ts` on import — no\r\n   * separate compile-to-disk step is needed.\r\n   */\r\n  private async doLoad(): Promise<WarlockConfig | undefined> {\r\n    const configPath = rootPath(\"warlock.config.ts\");\r\n\r\n    if (!(await fileExistsAsync(configPath))) {\r\n      devLogWarn(\r\n        \"warlock.config.ts is missing, it's highly recommended to create it, run warlock init to create it\",\r\n      );\r\n      return;\r\n    }\r\n\r\n    try {\r\n      const configModule = await import(pathToFileURL(configPath).href);\r\n      return configModule.default;\r\n    } catch (error) {\r\n      // `dev` registers a TS loader hook, and Node ≥ 22.18 / 23.6 strips types\r\n      // natively — in both cases the direct import above works. But `build` /\r\n      // `start` register no hook, so on an older Node the import throws\r\n      // ERR_UNKNOWN_FILE_EXTENSION. Transpile the config with esbuild ourselves\r\n      // so config loading is Node-version-independent rather than relying on an\r\n      // experimental runtime feature.\r\n      if (isUnknownTsExtensionError(error)) {\r\n        return await this.loadViaEsbuild(configPath);\r\n      }\r\n\r\n      throw new Error(`Failed to load warlock.config.ts: ${error}`);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Fallback config loader for runtimes without native TypeScript support.\r\n   *\r\n   * Transpiles `warlock.config.ts` with esbuild (already a core dependency),\r\n   * writes the result as a sibling `.mjs` — so the config's own imports (bare\r\n   * `@warlock.js/*` and any relative paths) resolve exactly as they would from\r\n   * the original location — imports it, then removes the temp file.\r\n   */\r\n  private async loadViaEsbuild(configPath: string): Promise<WarlockConfig | undefined> {\r\n    const { transformSync } = await import(\"esbuild\");\r\n    const source = await readFile(configPath, \"utf8\");\r\n\r\n    const { code } = transformSync(source, {\r\n      loader: \"ts\",\r\n      format: \"esm\",\r\n      target: `node${process.versions.node.split(\".\")[0]}`,\r\n      sourcefile: configPath,\r\n    });\r\n\r\n    // Unique sibling name so concurrent processes never clobber each other.\r\n    const compiledPath = configPath.replace(\r\n      /warlock\\.config\\.ts$/,\r\n      `.warlock.config.${process.pid}.mjs`,\r\n    );\r\n\r\n    await writeFile(compiledPath, code, \"utf8\");\r\n\r\n    try {\r\n      const configModule = await import(pathToFileURL(compiledPath).href);\r\n      return configModule.default;\r\n    } finally {\r\n      await unlink(compiledPath).catch(() => {});\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get config value by key (dot notation supported)\r\n   *\r\n   * @example\r\n   * config.get(\"server.port\") // Returns 3000\r\n   * config.get(\"cli.commands\") // Returns array of commands\r\n   *\r\n   * @param key - Config key (supports dot notation), autocompletes for first level only\r\n   * @returns The config value\r\n   * @throws Error if config is not loaded\r\n   */\r\n  public get<Key extends keyof WarlockConfig>(\r\n    key: Key,\r\n    defaultValue?: WarlockConfig[Key],\r\n  ): WarlockConfig[Key] {\r\n    if (!this.config) {\r\n      throw new Error(\"WarlockConfig not loaded. Call load() first or use lazyGet().\");\r\n    }\r\n\r\n    return get(this.config, key as string, defaultValue);\r\n  }\r\n\r\n  /**\r\n   * Lazy get - loads config if not already loaded\r\n   *\r\n   * @example\r\n   * const port = await config.lazyGet(\"server\");\r\n   *\r\n   * @param key - Config key (supports dot notation), autocompletes for first level only\r\n   * @param defaultValue - Default value if config key is undefined\r\n   * @returns The config value\r\n   */\r\n  async lazyGet<Key extends keyof WarlockConfig>(\r\n    key: Key,\r\n    defaultValue?: WarlockConfig[Key],\r\n  ): Promise<WarlockConfig[Key]> {\r\n    await this.load();\r\n    return this.get(key, defaultValue);\r\n  }\r\n\r\n  /**\r\n   * Check if config is loaded\r\n   */\r\n  public get isLoaded(): boolean {\r\n    return this.config !== undefined;\r\n  }\r\n\r\n  /**\r\n   * Get the entire config object\r\n   *\r\n   * @throws Error if config is not loaded\r\n   */\r\n  public getAll(): WarlockConfig {\r\n    if (!this.config) {\r\n      throw new Error(\"WarlockConfig not loaded. Call load() first or use lazyGet().\");\r\n    }\r\n\r\n    return this.config;\r\n  }\r\n\r\n  /**\r\n   * Reload config (useful for HMR/development)\r\n   */\r\n  public async reload(): Promise<void> {\r\n    this.config = undefined;\r\n    this.loading = undefined;\r\n    await this.load();\r\n  }\r\n}\r\n\r\n/**\r\n * Exported singleton instance\r\n *\r\n * @example\r\n * import { warlockConfig } from \"@warlock.js/core\";\r\n *\r\n * // Lazy load and get value\r\n * const port = await warlockConfig.lazyGet(\"server.port\");\r\n *\r\n * // Or load first, then get\r\n * await warlockConfig.load();\r\n * const commands = warlockConfig.get(\"cli.commands\");\r\n */\r\nexport const warlockConfigManager = new WarlockConfigManager();\r\n"],"mappings":";;;;;;;;;;;;;;;;;AAgBA,SAAgB,0BAA0B,OAAyB;CACjE,OACG,OAA6B,SAAS,gCACvC,kCAAkC,KAAK,OAAQ,OAAiB,OAAO,CAAC;AAE5E;;;;;;;AAQA,IAAa,uBAAb,MAAkC;;;;;;CAgBhC,MAAa,OAA2C;EAEtD,IAAI,KAAK,QACP,OAAO,KAAK;EAId,IAAI,KAAK,SACP,OAAO,KAAK;EAId,KAAK,UAAU,KAAK,OAAO;EAC3B,KAAK,SAAS,MAAM,KAAK;EACzB,KAAK,UAAU;EAEf,OAAO,KAAK;CACd;;;;;;;CAQA,MAAc,SAA6C;EACzD,MAAM,aAAa,SAAS,mBAAmB;EAE/C,IAAI,CAAE,MAAM,gBAAgB,UAAU,GAAI;GACxC,WACE,mGACF;GACA;EACF;EAEA,IAAI;GAEF,QAAO,MADoB,OAAO,cAAc,UAAU,CAAC,CAAC,MACzC,CAAC;EACtB,SAAS,OAAO;GAOd,IAAI,0BAA0B,KAAK,GACjC,OAAO,MAAM,KAAK,eAAe,UAAU;GAG7C,MAAM,IAAI,MAAM,qCAAqC,OAAO;EAC9D;CACF;;;;;;;;;CAUA,MAAc,eAAe,YAAwD;EACnF,MAAM,EAAE,kBAAkB,MAAM,OAAO;EAGvC,MAAM,EAAE,SAAS,cAAc,MAFV,SAAS,YAAY,MAAM,GAET;GACrC,QAAQ;GACR,QAAQ;GACR,QAAQ,OAAO,QAAQ,SAAS,KAAK,MAAM,GAAG,CAAC,CAAC;GAChD,YAAY;EACd,CAAC;EAGD,MAAM,eAAe,WAAW,QAC9B,wBACA,mBAAmB,QAAQ,IAAI,KACjC;EAEA,MAAM,UAAU,cAAc,MAAM,MAAM;EAE1C,IAAI;GAEF,QAAO,MADoB,OAAO,cAAc,YAAY,CAAC,CAAC,MAC3C,CAAC;EACtB,UAAU;GACR,MAAM,OAAO,YAAY,CAAC,CAAC,YAAY,CAAC,CAAC;EAC3C;CACF;;;;;;;;;;;;CAaA,AAAO,IACL,KACA,cACoB;EACpB,IAAI,CAAC,KAAK,QACR,MAAM,IAAI,MAAM,+DAA+D;EAGjF,OAAO,IAAI,KAAK,QAAQ,KAAe,YAAY;CACrD;;;;;;;;;;;CAYA,MAAM,QACJ,KACA,cAC6B;EAC7B,MAAM,KAAK,KAAK;EAChB,OAAO,KAAK,IAAI,KAAK,YAAY;CACnC;;;;CAKA,IAAW,WAAoB;EAC7B,OAAO,KAAK,WAAW;CACzB;;;;;;CAOA,AAAO,SAAwB;EAC7B,IAAI,CAAC,KAAK,QACR,MAAM,IAAI,MAAM,+DAA+D;EAGjF,OAAO,KAAK;CACd;;;;CAKA,MAAa,SAAwB;EACnC,KAAK,SAAS;EACd,KAAK,UAAU;EACf,MAAM,KAAK,KAAK;CAClB;AACF;;;;;;;;;;;;;;AAeA,MAAa,uBAAuB,IAAI,qBAAqB"}

package/llms-full.txt

@@ -3120,7 +3120,7 @@ const result = await measure("publish-event", () =>
 
 ---
 name: run-app
-description: 'Three operational commands — `warlock dev` (HMR + type-gen + health checks), `warlock build` (esbuild bundle), `warlock start` (spawn the production bundle). All flags, all `warlock.config.ts` knobs that shape them. Triggers: `warlock dev`, `warlock build`, `warlock start`, `devServer`, `--fresh`, `--skip-typings`, `--skip-health`, `outDirectory`, `outFile`, `sourcemap`; "start the dev server", "build for production", "run the bundle", "skip type generation", "tune watch globs"; typical config `warlock.config.ts > devServer / build`. Skip: writing a custom CLI — `@warlock.js/core/write-cli-command/SKILL.md`; config shape — `@warlock.js/core/configure-app/SKILL.md`; competing tooling `nodemon`, `tsx`, `ts-node-dev`, `esbuild` direct.'
+description: 'Three operational commands — `warlock dev` (HMR + type-gen + health checks), `warlock build` (esbuild bundle), `warlock start` (spawn the production bundle). All flags, all `warlock.config.ts` knobs that shape them. Triggers: `warlock dev`, `warlock build`, `warlock start`, `devServer`, `--fresh`, `--skip-typings`, `--skip-health`, `outdir`, `outFile`, `sourcemap`; "start the dev server", "build for production", "run the bundle", "skip type generation", "tune watch globs", "dev server keyboard shortcuts", "press r to restart", "press q to quit", "restart the dev server"; typical config `warlock.config.ts > devServer / build`. Skip: writing a custom CLI — `@warlock.js/core/write-cli-command/SKILL.md`; config shape — `@warlock.js/core/configure-app/SKILL.md`; competing tooling `nodemon`, `tsx`, `ts-node-dev`, `esbuild` direct.'
 ---
 
 # Warlock — run the app
@@ -3156,6 +3156,67 @@ Boots the framework in dev mode: file watcher, HMR-style module reload, on-disk
 
 When a flag is **not** passed, the corresponding `warlock.config.ts > devServer.*` value applies. When passed, the flag wins.
 
+### Keyboard shortcuts
+
+Once the server is ready, `warlock dev` listens for single keypresses:
+
+| Key      | Does                                                                       |
+| -------- | ---------------------------------------------------------------------------- |
+| `r`      | Restart the server on a fresh process.                                     |
+| `c`      | Clear the console.                                                         |
+| `q`      | Graceful shutdown, exit `0` — the same path as `Ctrl+C`.                    |
+| `h`      | Print the shortcuts that are armed right now.                              |
+| `u`      | **Only while an update notice is showing** — update every `@warlock.js/*` package, install, and restart. See [`update-packages/SKILL.md`](../update-packages/SKILL.md). |
+| `Ctrl+C` | Graceful shutdown, unchanged.                                              |
+
+A "restart" is a fresh process (`r` and `u` both use it) — see [The supervisor](#the-supervisor) below for how that works.
+
+Reading one key at a time needs stdin in **raw mode**, which takes `Ctrl+C` away from the terminal driver — the dev server re-raises `SIGINT` itself, and always leaves raw mode on shutdown (and while a package-manager install owns the terminal), so your shell is never left without line editing.
+
+Shortcuts are **TTY-gated**: with piped stdin, in CI, or under a process supervisor, nothing is registered, no hint is printed, and stdin is never touched.
+
+### The supervisor
+
+`warlock dev` runs as **two processes**, not one:
+
+```
+shell
+└─ warlock dev                      ← supervisor: owns the terminal, loads nothing
+   └─ warlock dev (WARLOCK_DEV_WORKER=1)  ← the actual server, disposable
+```
+
+The supervisor spawns the worker with `stdio: "inherit"` and mirrors its exit code. To restart, the worker shuts down cleanly — freeing the http port — and exits `75`; the supervisor spawns a replacement. **The tree never gets deeper**, however many restarts happen.
+
+The supervisor is chosen in the `dev` command's `preAction`, which runs *before* the preloaders — deliberately, so the supervisor never loads config or starts connectors. A supervisor holding a second database connection open for the session would be a real bug, not a cosmetic one.
+
+Signals: `SIGINT` reaches the worker directly (same process group), so the supervisor ignores it and only notes that the next exit is final — acting on it would exit the parent while the worker was still draining. `SIGTERM` / `SIGHUP` are forwarded explicitly, since they don't propagate to the group on Windows. After any worker exits, the supervisor puts stdin back out of raw mode in case the worker was killed before it could.
+
+`restartDevServer()` returns `false` instead of exiting when there is no supervisor — a programmatic `startDevelopmentServer()` call — so nothing kills a server it can't replace.
+
+### Crash recovery
+
+A worker that dies **after running healthily for at least 5s** — OOM, a native crash, a dead loader thread — is replaced automatically:
+
+```
+14:31:02 Development server was killed by SIGSEGV — restarting.
+```
+
+A worker that dies *sooner* than that failed to **boot** — a broken config, a port already taken — and it has already printed why. Restarting there would just reprint the same error and bury it, so the supervisor mirrors the exit code and stops.
+
+Flapping is capped: more than 3 crashes inside 60s and the supervisor gives up rather than restarting behind your back.
+
+An explicit restart (`r`, `u`, a config change) is a *request*, not a crash, so the uptime rule never swallows it.
+
+### Restart on config change
+
+`warlock.config.ts` and `.env*` are read at boot and feed every config that derives from them, so they cannot be hot-reloaded — a "reload" would leave running services on stale values. When one changes, the dev server restarts itself:
+
+```
+14:22:07 warlock.config.ts changed — restarting to apply.
+```
+
+Set `devServer.restartOnConfigChange: false` for the previous behaviour (a warning telling you to restart yourself). The same warning is printed if a restart is declined or isn't possible, and any ordinary code files that shared the batch still hot-reload normally.
+
 ### What it preloads
 
 ```ts
@@ -3187,6 +3248,7 @@ export default defineConfig({
     },
     generateTypings: true,             // background type generation
     checkForUpdates: true,             // notify on a newer @warlock.js/core at dev start
+    restartOnConfigChange: true,       // restart when warlock.config.ts / .env* changes
     healthCheckers: [...] /* or false */,
     transpileCacheDebug: false,        // name cache files <slug>.<hash>.js w/ // @source markers
   },
@@ -3197,7 +3259,8 @@ export default defineConfig({
 - **`generateTypings`** — turn off if you're committing generated typings and don't want them rewritten on every boot. The `--skip-typings` flag is the per-run version.
 - **`healthCheckers`** — custom file health checker contracts (or `false` to disable). The `--skip-health` flag is the per-run version.
 - **`transpileCacheDebug`** — diagnostic only. Names `.warlock/transpile/*.js` files `<slug>.<hash>.js` and appends `// @source <path>` markers so you can eyeball which cache entry came from which source. Leave off in normal use.
-- **`checkForUpdates`** — on `warlock dev` start, check npm for a newer `@warlock.js/core` and print a one-line notice if one exists. Best-effort and non-blocking; auto-skipped in CI and non-TTY shells. Run `warlock update` to upgrade. See [`update-packages/SKILL.md`](../update-packages/SKILL.md).
+- **`checkForUpdates`** — on `warlock dev` start, check npm for a newer `@warlock.js/core` and print a one-line notice if one exists. Best-effort and non-blocking; auto-skipped in CI and non-TTY shells. In an interactive terminal the notice arms a **`u` shortcut** that updates every `@warlock.js/*` package, installs, and restarts the server; elsewhere it prints `npx warlock update` instead. The registry answer is cached for 24h in `.warlock/update-check.json`, so a day of restarts costs one lookup. See [`update-packages/SKILL.md`](../update-packages/SKILL.md).
+- **`restartOnConfigChange`** — restart the dev server when `warlock.config.ts` or any `.env*` changes (default `true`). Set `false` to get a warning instead and restart by hand. Neither file can be hot-reloaded, so without a restart the running services keep the old values.
 
 ## `warlock build` — production bundle
 
@@ -3208,7 +3271,7 @@ esbuild bundle of the app down to a single JS file in `dist/`. No flags — ever
 ```ts title="warlock.config.ts"
 export default defineConfig({
   build: {
-    outDirectory: "dist",        // default — relative or absolute
+    outdir: "dist",        // default — relative or absolute
     outFile: "app.js",            // default — bundle filename
     minify: true,                 // default — esbuild minify
     sourcemap: true,              // default — true | false | "inline" | "linked"
@@ -3218,7 +3281,7 @@ export default defineConfig({
 
 Defaults are sensible for the typical "Node service" deployment. Knobs to actually reach for:
 
-- **`outDirectory`** — override when your deployment pipeline expects a different folder (e.g. `build/`, `.build/`).
+- **`outdir`** — override when your deployment pipeline expects a different folder (e.g. `build/`, `.build/`). `outDirectory` is accepted as an alias (the docs used that name for several releases while the code only read `outdir`); `outdir` wins if both are set.
 - **`outFile`** — override when bundling multiple Warlock apps into one image and they need distinct entry filenames.
 - **`minify: false`** — flip to debug a production-only bug. Larger bundle, readable stack traces.
 - **`sourcemap: "inline"`** — embed the source map in the bundle. Useful when your error reporter only captures the bundle and can't fetch a `.map` sidecar.
@@ -3231,7 +3294,7 @@ Just `warlockConfig: true`. Build doesn't need the app booted — it reads `warl
 ### Where the bundle lands
 
 ```
-<cwd>/<outDirectory>/<outFile>
+<cwd>/<outdir>/<outFile>
 └─ default: <cwd>/dist/app.js
 ```
 
@@ -3325,7 +3388,7 @@ import { defineConfig, env } from "@warlock.js/core";
 
 export default defineConfig({
   build: {
-    outDirectory: env("BUILD_OUT", "dist"),
+    outdir: env("BUILD_OUT", "dist"),
     outFile: env("BUILD_FILE", "app.js"),
   },
 });
@@ -3369,7 +3432,7 @@ NODE_OPTIONS=--max-old-space-size=4096 yarn warlock start
 - **`--fresh` only deletes the manifest, not the transpile cache.** If you're chasing a stale-compile bug, `rm -rf .warlock/` clears everything. The manifest restoring is what `--fresh` solves.
 - **`warlock build` does NOT run migrations.** Production bundles ship the migration files but don't apply them. Run `yarn warlock migrate` against the production DB separately.
 - **`warlock start` requires a built bundle.** Run `warlock build` first, or you'll spawn `node` against a non-existent file and crash immediately.
-- **`outDirectory` is the directory, `outFile` is the filename within it.** A common mistake is putting the full path in one and leaving the other default — you end up with `<full-path>/app.js` or `dist/<full-path>`. They concatenate.
+- **`outdir` is the directory, `outFile` is the filename within it.** A common mistake is putting the full path in one and leaving the other default — you end up with `<full-path>/app.js` or `dist/<full-path>`. They concatenate.
 - **`sourcemap: false` cascades to `start`.** Stack traces lose `.ts` precision. Keep sourcemaps on unless artifact size is a hard constraint.
 - **`NODE_ENV` is not set by these commands.** The deployment env (your Dockerfile, CI, hosting provider) sets it. Forget it on a production server and `Application.isProduction` returns `false`, which flips cookie security, CORS, logging — silently. Always set `NODE_ENV=production` in production deployments.
 - **`prestart` runs once on dev boot, not on reload.** If you're seeding test data in `src/app/prestart.ts`, it fires on `warlock dev` startup only. HMR reloads don't re-run it.
@@ -4939,7 +5002,7 @@ describe("slugify", () => {
 
 ---
 name: update-packages
-description: 'Keep a project current with `warlock update` — bump every `@warlock.js/*` dependency in package.json to its latest published version (range operator preserved), then run the lockfile-detected package manager install. Also covers the `warlock dev` update notice and the `devServer.checkForUpdates` toggle. Triggers: `warlock update`, `--no-install`, `checkForUpdates`, `fetchLatestVersion`, `isNewerVersion`; "update warlock packages", "upgrade the framework", "is there a new warlock version", "update notice in the dev server", "bump @warlock.js/* to latest"; typical CLI `warlock update`. Skip: dev/build/start runtime — `@warlock.js/core/run-app/SKILL.md`; writing a custom command — `@warlock.js/core/write-cli-command/SKILL.md`; installing a NEW feature package (auth, mail, storage) — that is `warlock add`; releasing/publishing the framework — workspace release tooling, not this command.'
+description: 'Keep a project current with `warlock update` — bump every `@warlock.js/*` dependency in package.json to its latest published version (range operator preserved), then run the lockfile-detected package manager install. Also covers the `warlock dev` update notice, its `u` update-and-restart keyboard shortcut, and the `devServer.checkForUpdates` toggle. Triggers: `warlock update`, `--no-install`, `--dry-run`, `--check`, `checkForUpdates`, `fetchLatestVersion`, `isNewerVersion`; "update warlock packages", "upgrade the framework", "is there a new warlock version", "update notice in the dev server", "press u to update", "dev server keyboard shortcut", "update check offline", "bump @warlock.js/* to latest"; typical CLI `warlock update`. Skip: dev/build/start runtime — `@warlock.js/core/run-app/SKILL.md`; writing a custom command — `@warlock.js/core/write-cli-command/SKILL.md`; installing a NEW feature package (auth, mail, storage) — that is `warlock add`; releasing/publishing the framework — workspace release tooling, not this command.'
 ---
 
 # Warlock — update the framework
@@ -4951,11 +5014,24 @@ description: 'Keep a project current with `warlock update` — bump every `@warl
 ```bash
 warlock update                  # bump every @warlock.js/* dep to latest, then install
 warlock update --no-install     # rewrite package.json only; install yourself later
+warlock update --dry-run        # show what would change; touch nothing
+warlock update --check          # same, but exit 1 when behind — a CI gate
 ```
 
 | Flag           | Type    | Purpose                                                                             |
 | -------------- | ------- | ----------------------------------------------------------------------------------- |
 | `--no-install` | boolean | Rewrite the versions in `package.json` without running the package manager install. |
+| `--dry-run`    | boolean | Report which packages would be updated without writing package.json or installing.  |
+| `--check`      | boolean | Like `--dry-run`, but **exits 1** when any package is behind.                       |
+
+`--check` is the CI form — its exit code carries the answer:
+
+| Exit | Meaning                                                              |
+| ---- | -------------------------------------------------------------------- |
+| `0`  | Every `@warlock.js/*` package is current.                            |
+| `1`  | At least one is behind (or the registry could not be reached).       |
+
+Both flags imply a dry run, so neither ever writes to `package.json`.
 
 What it does, in order:
 
@@ -4963,21 +5039,61 @@ What it does, in order:
 2. Collects every `@warlock.js/*` package across `dependencies` and `devDependencies`. Only the `@warlock.js/` scope is considered — `create-warlock` and unrelated dependencies are never touched.
 3. Looks up each package's latest version on the npm registry, in parallel.
 4. Rewrites each matching spec, **preserving the range operator**: `^4.2.0` → `^4.3.0`, `~4.2.0` → `~4.3.0`, an exact `4.2.0` → `4.3.0`. Specs that are not a plain semver — `workspace:*`, `*`, `latest`, git/file URLs — are left exactly as written, and any package already at or ahead of latest is skipped.
-5. Runs the project's install to reconcile `node_modules` — `npm install` / `yarn install` / `pnpm install`, chosen by the lockfile present (`package-lock.json` / `yarn.lock` / `pnpm-lock.yaml`, npm as the fallback). Skipped with `--no-install`.
+5. Runs the project's install to reconcile `node_modules`, chosen by the lockfile present. Skipped with `--no-install`.
+
+| Lockfile                        | Install         | Add (`warlock add`) |
+| ------------------------------- | --------------- | ------------------- |
+| `bun.lock` / `bun.lockb`        | `bun install`   | `bun add`           |
+| `package-lock.json`             | `npm install`   | `npm install`       |
+| `yarn.lock`                     | `yarn install`  | `yarn add`          |
+| `pnpm-lock.yaml`                | `pnpm install`  | `pnpm add`          |
+| *none*                          | `npm install`   | `npm install`       |
+
+Bun is checked **first**: a Bun project may also carry a `yarn.lock` (Bun writes one for tooling compatibility), and matching yarn there would run the wrong installer against the wrong lockfile. `warlock update` and `warlock add` share this detection, so they can never disagree.
 
 Re-running on an already-current project is a no-op: nothing resolves as newer, so it prints "All @warlock.js packages are already up to date" and exits without writing or installing.
 
+**Offline is not "up to date".** If *every* registry lookup fails, the command says so and changes nothing:
+
+```
+⚠ Could not reach the npm registry — no versions were changed. Check your connection and try again.
+```
+
+If the install fails after the versions were rewritten, `package.json` keeps the new versions (re-run your package manager to finish) and the CLI exits non-zero.
+
 ## The dev-server update notice
 
 On start, `warlock dev` checks npm for a newer `@warlock.js/core` and prints a one-line notice when one exists:
 
 ```
-  ⚡ A new version of Warlock.js is available  4.2.11 → 4.3.0
-     Run  npx warlock update  to update all @warlock.js packages
+  ⚡ A new version of Warlock.js is available  4.8.2 → 4.9.0
+     Press u to update all @warlock.js packages and restart
      Changelog  https://warlock.js.org/changelog/
 ```
 
-Core's version stands in for the whole family (lockstep), so a single lookup is enough. The check is **best-effort and non-blocking** — it runs fire-and-forget after the server is ready, never delays or breaks startup, and stays silent on any failure (offline, registry down, timeout).
+Core's version stands in for the whole family (lockstep), so a single lookup is enough. The check is **best-effort and non-blocking** — it runs fire-and-forget after the server is ready, never delays or breaks startup, and stays silent on any failure (offline, registry down, timeout). Its abort budget is 5s, much shorter than the `warlock update` command's, so a hanging network leaves nothing behind.
+
+**The answer is cached for 24 hours** in `.warlock/update-check.json`, so a normal day of dev-server restarts costs one registry lookup rather than one per boot. Three deliberate details: a **failed** lookup is never cached (one flaky moment must not silence the notice for a day), an entry stamped in the *future* is ignored (a clock that moves backwards would otherwise pin the cache as fresh forever), and the entry is **dropped** once `u` actually applies an update, so the next boot compares against the version you just installed.
+
+### The `u` shortcut
+
+Pressing `u` on that notice runs the whole upgrade without leaving the dev server:
+
+1. The shortcut is disarmed and the terminal handed back, so the package manager owns stdin.
+2. Every `@warlock.js/*` dependency is rewritten to latest and installed — exactly what `warlock update` does.
+3. The worker shuts down (freeing the http port) and exits `75`; the `warlock dev` supervisor spawns a replacement on the new version. See [`run-app/SKILL.md`](../run-app/SKILL.md) for the supervisor.
+
+What happens when it doesn't go to plan:
+
+| Situation                     | Result                                                                       |
+| ----------------------------- | ----------------------------------------------------------------------------- |
+| Registry unreachable          | Nothing changes, the server keeps serving, and `u` is re-armed for a retry.   |
+| Install failed                | `package.json` keeps the new versions; `u` is **not** re-armed — finish the install and restart by hand. |
+| Restart could not be launched | The notice tells you to restart manually.                                     |
+
+The shortcut is only offered when stdin is an interactive TTY. When it isn't (CI, piped stdin, a process supervisor), the notice falls back to the `Run npx warlock update` line instead — it never silently does nothing.
+
+`u` joins the dev server's standing shortcut bar (`r` restart, `c` clear, `q` quit, `h` help) — press `h` to list whatever is armed. See [`run-app/SKILL.md`](../run-app/SKILL.md) for the bar and the raw-mode / `Ctrl+C` contract.
 
 It is automatically skipped when:
 
@@ -5005,9 +5121,11 @@ Two small zero-dependency utilities back the tooling and are exported from `@war
 
 ## Gotchas
 
+- **Bun projects are detected first.** A `bun.lock` or `bun.lockb` wins over any other lockfile in the same project.
 - **Only the `@warlock.js/` scope is updated.** Mongez packages (`@mongez/*`), `create-warlock`, and everything else are left alone — update those with your package manager directly.
 - **Non-semver specs are intentionally skipped.** A `workspace:*` or `*` dependency stays as written; `update` will not pin it to a concrete version.
-- **The notice never blocks dev.** If npm is unreachable, `warlock dev` behaves exactly as before — no delay, no error.
+- **The notice never blocks dev.** If npm is unreachable, `warlock dev` behaves exactly as before — no delay, no error, no notice, and no `u` shortcut.
+- **`u` is not offered without a TTY.** Don't expect it in CI logs or piped output; the notice prints the command instead.
 - **`warlock update` is not `warlock add`.** `add` installs a *new* feature package and runs its setup hooks; `update` only bumps the versions of packages you already depend on.
 
 ## See also

package/llms.txt

@@ -22,13 +22,13 @@
 - [register-route](@warlock.js/core/register-route/SKILL.md): Register HTTP routes via @warlock.js/core's router — single routes, prefix groups, middleware-guarded blocks, and RESTful resource chains. Routes always live in `src/app/<module>/routes.ts`. Triggers: `router.get`, `router.post`, `router.prefix`, `router.group`, `router.route`, `guarded`; "add a route", "wire a controller to a URL", "group routes by prefix", "register a RESTful resource"; typical import `import { router } from "@warlock.js/core"`. Skip: handler shape — `@warlock.js/core/create-controller/SKILL.md`; CRUD chain details — `@warlock.js/core/build-restful/SKILL.md`; middleware authoring — `@warlock.js/core/write-middleware/SKILL.md`; competing libs `express`, `fastify`, `koa`, `@nestjs/common`.
 - [resolve-path](@warlock.js/core/resolve-path/SKILL.md): Path helpers anchored at `process.cwd()` — `rootPath`, `srcPath`, `appPath`, `configPath`, `publicPath`, `storagePath`, `uploadsPath`, `cachePath`, `logsPath`, `tempPath`, `warlockPath`, `sanitizePath`. Optional `uploads.root` config overrides the uploads anchor. Triggers: `appPath`, `configPath`, `uploadsPath`, `storagePath`, `publicPath`, `cachePath`, `logsPath`, `tempPath`, `sanitizePath`, `paths`; "resolve a path inside src/app", "absolute upload destination", "sanitize a user filename", "ship uploads to a mounted volume"; typical import `import { appPath, uploadsPath } from "@warlock.js/core"`. Skip: HTTP URL helpers — `@warlock.js/core/build-url/SKILL.md`; app metadata — `@warlock.js/core/use-app-context/SKILL.md`; storage abstraction — `@warlock.js/core/store-file/SKILL.md`; competing patterns: `path.join(process.cwd(), ...)`, hand-rolled directory constants.
 - [retry-operation](@warlock.js/core/retry-operation/SKILL.md): Wrap a flaky operation with `retry(fn, options)` — now provided by `@mongez/reinforcements` (not `@warlock.js/core`). `attempts` total tries, `delay` + `backoff` (linear/exponential/fn), `maxDelay`, `jitter`, `shouldRetry` to bail on permanent errors, `signal` to cancel, plus `retryable()` to pre-bind options. Triggers: `retry`, `retryable`, `RetryOptions`, `attempts`, `backoff`, `jitter`, `maxDelay`, `shouldRetry`, `signal`; "retry a flaky API call", "handle transient errors", "exponential backoff with jitter", "wrap an external request"; typical import `import { retry } from "@mongez/reinforcements"`. Skip: timing the retried op — `@warlock.js/core/benchmark-code/SKILL.md`; use-case-level `retry` option — `@warlock.js/core/write-use-case/SKILL.md`; competing libs `p-retry`, `async-retry`, `cockatiel`.
-- [run-app](@warlock.js/core/run-app/SKILL.md): Three operational commands — `warlock dev` (HMR + type-gen + health checks), `warlock build` (esbuild bundle), `warlock start` (spawn the production bundle). All flags, all `warlock.config.ts` knobs that shape them. Triggers: `warlock dev`, `warlock build`, `warlock start`, `devServer`, `--fresh`, `--skip-typings`, `--skip-health`, `outDirectory`, `outFile`, `sourcemap`; "start the dev server", "build for production", "run the bundle", "skip type generation", "tune watch globs"; typical config `warlock.config.ts > devServer / build`. Skip: writing a custom CLI — `@warlock.js/core/write-cli-command/SKILL.md`; config shape — `@warlock.js/core/configure-app/SKILL.md`; competing tooling `nodemon`, `tsx`, `ts-node-dev`, `esbuild` direct.
+- [run-app](@warlock.js/core/run-app/SKILL.md): Three operational commands — `warlock dev` (HMR + type-gen + health checks), `warlock build` (esbuild bundle), `warlock start` (spawn the production bundle). All flags, all `warlock.config.ts` knobs that shape them. Triggers: `warlock dev`, `warlock build`, `warlock start`, `devServer`, `--fresh`, `--skip-typings`, `--skip-health`, `outdir`, `outFile`, `sourcemap`; "start the dev server", "build for production", "run the bundle", "skip type generation", "tune watch globs", "dev server keyboard shortcuts", "press r to restart", "press q to quit", "restart the dev server"; typical config `warlock.config.ts > devServer / build`. Skip: writing a custom CLI — `@warlock.js/core/write-cli-command/SKILL.md`; config shape — `@warlock.js/core/configure-app/SKILL.md`; competing tooling `nodemon`, `tsx`, `ts-node-dev`, `esbuild` direct.
 - [send-mail](@warlock.js/core/send-mail/SKILL.md): Send transactional email — `Mail` fluent builder, `sendMail()` direct call, React Email components. Test mode auto-captures into an in-memory mailbox; dev mode logs. Triggers: `Mail.to`, `sendMail`, `setMailMode`, `mailEvents`, `assertMailSent`, `getTestMailbox`, `wasMailSentTo`, `closeAllMailers`; "send a transactional email", "build a React Email template", "configure SMTP or SES", "assert an email was sent in tests"; typical import `import { Mail, sendMail } from "@warlock.js/core"`. Skip: per-config wiring — `@warlock.js/core/configure-app/SKILL.md`; layered service patterns — `@warlock.js/core/warlock-conventions/SKILL.md`; competing libs `nodemailer` direct, `@sendgrid/mail`, `resend`, `mailgun.js`.
 - [send-response](@warlock.js/core/send-response/SKILL.md): Send HTTP responses via @warlock.js/core's Response helpers — success/error variants, status helpers, redirects, files, streams, and SSE. Picking the right helper carries the HTTP semantic without manual status codes. Triggers: `response.success`, `response.successCreate`, `response.notFound`, `response.forbidden`, `response.badRequest`, `response.sendFile`, `response.stream`, `response.sse`, `response.replay`, `ResourceNotFoundError`, `ForbiddenError`; "return a 201 from a controller", "send a file", "stream Server-Sent Events", "throw HTTP-shaped errors from services"; typical import `import type { RequestHandler, Response } from "@warlock.js/core"`. Skip: controller shape — `@warlock.js/core/create-controller/SKILL.md`; route registration — `@warlock.js/core/register-route/SKILL.md`; competing patterns: hand-rolled status codes via `reply.code(404).send(...)`, raw Fastify reply.
 - [store-file](@warlock.js/core/store-file/SKILL.md): Read/write/delete files via the `storage` singleton — disks, drivers (local/S3/R2/DO Spaces), `storage.use(name)`, `StorageFile` handles, presigned URLs. Triggers: `storage.put`, `storage.get`, `storage.use`, `StorageFile`, `storageConfigurations`, `getPresignedUrl`, `getPresignedUploadUrl`; "save an uploaded file", "switch between local and S3", "generate a presigned URL", "read file metadata"; typical import `import { storage } from "@warlock.js/core"`. Skip: multipart parsing + image chain — `@warlock.js/core/upload-file/SKILL.md`; image transforms — `@warlock.js/core/process-image/SKILL.md`; storage config shape — `@warlock.js/core/configure-app/SKILL.md`; competing libs `@aws-sdk/client-s3`, `multer`, `formidable`.
 - [test-http](@warlock.js/core/test-http/SKILL.md): Integration tests against a real HTTP server — `startHttpTestServer()` boots one shared server in globalSetup, then `testGet` / `testPost` / `expectJson` make typed requests against it. Triggers: `startHttpTestServer`, `stopHttpTestServer`, `testGet`, `testPost`, `testPut`, `testPatch`, `testDelete`, `expectJson`, `getTestServerUrl`, `testRequest`; "integration-test a controller", "end-to-end HTTP test", "globalSetup HTTP server", "assert status and body shape"; typical import `import { testGet, testPost, expectJson } from "@warlock.js/core"`. Skip: pure unit tests — `@warlock.js/core/test-service/SKILL.md`; controller shape — `@warlock.js/core/create-controller/SKILL.md`; competing libs `supertest`, `light-my-request`, `nock`.
 - [test-service](@warlock.js/core/test-service/SKILL.md): Pure unit tests against services, repositories, models, and use-cases — `setupTest({ connectors })` bootstraps each Vitest worker with its own DB/cache connections so you can call your code directly. Triggers: `setupTest`, `src/test-setup.ts`, `tests.connectors`, `Application.setEnvironment`; "unit-test a service", "test a repository query", "vitest setupFiles", "skip connectors for pure-logic tests"; typical import `import { setupTest } from "@warlock.js/core"`. Skip: HTTP integration — `@warlock.js/core/test-http/SKILL.md`; warlock add test scaffold — `@warlock.js/core/write-cli-command/SKILL.md`; competing tooling: jest direct, `supertest`, `nock`.
-- [update-packages](@warlock.js/core/update-packages/SKILL.md): Keep a project current with `warlock update` — bump every `@warlock.js/*` dependency in package.json to its latest published version (range operator preserved), then run the lockfile-detected package manager install. Also covers the `warlock dev` update notice and the `devServer.checkForUpdates` toggle. Triggers: `warlock update`, `--no-install`, `checkForUpdates`, `fetchLatestVersion`, `isNewerVersion`; "update warlock packages", "upgrade the framework", "is there a new warlock version", "update notice in the dev server", "bump @warlock.js/* to latest"; typical CLI `warlock update`. Skip: dev/build/start runtime — `@warlock.js/core/run-app/SKILL.md`; writing a custom command — `@warlock.js/core/write-cli-command/SKILL.md`; installing a NEW feature package (auth, mail, storage) — that is `warlock add`; releasing/publishing the framework — workspace release tooling, not this command.
+- [update-packages](@warlock.js/core/update-packages/SKILL.md): Keep a project current with `warlock update` — bump every `@warlock.js/*` dependency in package.json to its latest published version (range operator preserved), then run the lockfile-detected package manager install. Also covers the `warlock dev` update notice, its `u` update-and-restart keyboard shortcut, and the `devServer.checkForUpdates` toggle. Triggers: `warlock update`, `--no-install`, `--dry-run`, `--check`, `checkForUpdates`, `fetchLatestVersion`, `isNewerVersion`; "update warlock packages", "upgrade the framework", "is there a new warlock version", "update notice in the dev server", "press u to update", "dev server keyboard shortcut", "update check offline", "bump @warlock.js/* to latest"; typical CLI `warlock update`. Skip: dev/build/start runtime — `@warlock.js/core/run-app/SKILL.md`; writing a custom command — `@warlock.js/core/write-cli-command/SKILL.md`; installing a NEW feature package (auth, mail, storage) — that is `warlock add`; releasing/publishing the framework — workspace release tooling, not this command.
 - [upload-file](@warlock.js/core/upload-file/SKILL.md): Handle multipart file uploads — read via `request.file()` or `request.validated()`, validate with `v.file()`, save via `UploadedFile.save()` or the storage layer, transform images inline. Triggers: `UploadedFile`, `request.file`, `v.file`, `.save`, `.saveAs`, `.resize`, `.format`, `.quality`, `.image`, `.mimeType`, `.maxSize`; "accept a file upload", "validate file size and mime", "save to S3 or local disk", "resize an uploaded image on save"; typical import `import type { UploadedFile, RequestHandler } from "@warlock.js/core"`. Skip: storage drivers + presigned URLs — `@warlock.js/core/store-file/SKILL.md`; image-only transforms — `@warlock.js/core/process-image/SKILL.md`; schema rules — `@warlock.js/core/validate-input/SKILL.md`; competing libs `multer`, `formidable`, `busboy`.
 - [use-app-context](@warlock.js/core/use-app-context/SKILL.md): Read app-wide context — the `Application` static class (env, version, uptime, runtime strategy, boot lifecycle) plus the `app` runtime accessor (live Fastify, socket.io, router, database via the DI container). Triggers: `Application.isProduction`, `Application.environment`, `Application.runtimeStrategy`, `Application.uptime`, `Application.version`, `Application.onceBooted`, `Application.whenBooted`, `Application.isBooted`, `Application.onShutdown`, `Application.isShuttingDown`, `app.http`, `app.socket`, `app.database`, `app.router`; "branch on environment", "reach the live Fastify instance", "framework version in health endpoint", "dev vs production runtime check", "run code once the app is fully booted", "after all connectors started", "app booted hook", "run cleanup before shutdown", "graceful shutdown hook"; typical import `import { Application, app } from "@warlock.js/core"`. Skip: path helpers — `@warlock.js/core/resolve-path/SKILL.md`; connector start order — `@warlock.js/core/add-connector/SKILL.md`; competing patterns: bare `process.env.NODE_ENV`, ad-hoc Fastify imports.
 - [use-localization](@warlock.js/core/use-localization/SKILL.md): Multi-locale translations via `groupedTranslations` (declare keys), `t()` / `request.t()` / `request.trans()` (look up), `request.getLocaleCode()` (detect locale from headers/query), `getLocalized` (pick the right value from a localized-array column). Triggers: `groupedTranslations`, `t`, `request.t`, `request.trans`, `request.transFrom`, `request.getLocaleCode`, `request.setLocaleCode`, `getLocalized`; "add a translation key", "resolve a localized error message", "detect request locale", "pick the right per-locale column value"; typical import `import { t, getLocalized } from "@warlock.js/core"`. Skip: resource output — `@warlock.js/core/define-resource/SKILL.md`; module scaffold — `@warlock.js/core/create-module/SKILL.md`; competing libs `i18next`, `react-intl`, raw `@mongez/localization`.

package/package.json

@@ -36,13 +36,13 @@
     "@mongez/slug": "^1.0.7",
     "@mongez/supportive-is": "^2.1.3",
     "@mongez/time-wizard": "^1.0.6",
-    "@warlock.js/auth": "4.8.2",
-    "@warlock.js/cache": "4.8.2",
-    "@warlock.js/cascade": "4.8.2",
-    "@warlock.js/context": "4.8.2",
-    "@warlock.js/logger": "4.8.2",
-    "@warlock.js/seal": "4.8.2",
-    "@warlock.js/fs": "4.8.2",
+    "@warlock.js/auth": "4.9.1",
+    "@warlock.js/cache": "4.9.1",
+    "@warlock.js/cascade": "4.9.1",
+    "@warlock.js/context": "4.9.1",
+    "@warlock.js/logger": "4.9.1",
+    "@warlock.js/seal": "4.9.1",
+    "@warlock.js/fs": "4.9.1",
     "chokidar": "^5.0.0",
     "dayjs": "^1.11.19",
     "es-module-lexer": "^2.0.0",
@@ -68,15 +68,15 @@
     "react": "^19.2.3",
     "react-dom": "^19.2.3",
     "@react-email/render": "^2.0.5",
-    "@warlock.js/herald": "4.8.2",
-    "@warlock.js/ai": "4.8.2",
-    "@warlock.js/access": "4.8.2",
-    "@warlock.js/notifications": "4.8.2"
+    "@warlock.js/herald": "4.9.1",
+    "@warlock.js/ai": "4.9.1",
+    "@warlock.js/access": "4.9.1",
+    "@warlock.js/notifications": "4.9.1"
   },
   "bin": {
     "warlock": "bin/warlock.js"
   },
-  "version": "4.8.2",
+  "version": "4.9.1",
   "type": "module",
   "main": "./esm/index.mjs",
   "module": "./esm/index.mjs",

package/skills/run-app/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: run-app
-description: 'Three operational commands — `warlock dev` (HMR + type-gen + health checks), `warlock build` (esbuild bundle), `warlock start` (spawn the production bundle). All flags, all `warlock.config.ts` knobs that shape them. Triggers: `warlock dev`, `warlock build`, `warlock start`, `devServer`, `--fresh`, `--skip-typings`, `--skip-health`, `outDirectory`, `outFile`, `sourcemap`; "start the dev server", "build for production", "run the bundle", "skip type generation", "tune watch globs"; typical config `warlock.config.ts > devServer / build`. Skip: writing a custom CLI — `@warlock.js/core/write-cli-command/SKILL.md`; config shape — `@warlock.js/core/configure-app/SKILL.md`; competing tooling `nodemon`, `tsx`, `ts-node-dev`, `esbuild` direct.'
+description: 'Three operational commands — `warlock dev` (HMR + type-gen + health checks), `warlock build` (esbuild bundle), `warlock start` (spawn the production bundle). All flags, all `warlock.config.ts` knobs that shape them. Triggers: `warlock dev`, `warlock build`, `warlock start`, `devServer`, `--fresh`, `--skip-typings`, `--skip-health`, `outdir`, `outFile`, `sourcemap`; "start the dev server", "build for production", "run the bundle", "skip type generation", "tune watch globs", "dev server keyboard shortcuts", "press r to restart", "press q to quit", "restart the dev server"; typical config `warlock.config.ts > devServer / build`. Skip: writing a custom CLI — `@warlock.js/core/write-cli-command/SKILL.md`; config shape — `@warlock.js/core/configure-app/SKILL.md`; competing tooling `nodemon`, `tsx`, `ts-node-dev`, `esbuild` direct.'
 ---
 
 # Warlock — run the app
@@ -36,6 +36,67 @@ Boots the framework in dev mode: file watcher, HMR-style module reload, on-disk
 
 When a flag is **not** passed, the corresponding `warlock.config.ts > devServer.*` value applies. When passed, the flag wins.
 
+### Keyboard shortcuts
+
+Once the server is ready, `warlock dev` listens for single keypresses:
+
+| Key      | Does                                                                       |
+| -------- | ---------------------------------------------------------------------------- |
+| `r`      | Restart the server on a fresh process.                                     |
+| `c`      | Clear the console.                                                         |
+| `q`      | Graceful shutdown, exit `0` — the same path as `Ctrl+C`.                    |
+| `h`      | Print the shortcuts that are armed right now.                              |
+| `u`      | **Only while an update notice is showing** — update every `@warlock.js/*` package, install, and restart. See [`update-packages/SKILL.md`](../update-packages/SKILL.md). |
+| `Ctrl+C` | Graceful shutdown, unchanged.                                              |
+
+A "restart" is a fresh process (`r` and `u` both use it) — see [The supervisor](#the-supervisor) below for how that works.
+
+Reading one key at a time needs stdin in **raw mode**, which takes `Ctrl+C` away from the terminal driver — the dev server re-raises `SIGINT` itself, and always leaves raw mode on shutdown (and while a package-manager install owns the terminal), so your shell is never left without line editing.
+
+Shortcuts are **TTY-gated**: with piped stdin, in CI, or under a process supervisor, nothing is registered, no hint is printed, and stdin is never touched.
+
+### The supervisor
+
+`warlock dev` runs as **two processes**, not one:
+
+```
+shell
+└─ warlock dev                      ← supervisor: owns the terminal, loads nothing
+   └─ warlock dev (WARLOCK_DEV_WORKER=1)  ← the actual server, disposable
+```
+
+The supervisor spawns the worker with `stdio: "inherit"` and mirrors its exit code. To restart, the worker shuts down cleanly — freeing the http port — and exits `75`; the supervisor spawns a replacement. **The tree never gets deeper**, however many restarts happen.
+
+The supervisor is chosen in the `dev` command's `preAction`, which runs *before* the preloaders — deliberately, so the supervisor never loads config or starts connectors. A supervisor holding a second database connection open for the session would be a real bug, not a cosmetic one.
+
+Signals: `SIGINT` reaches the worker directly (same process group), so the supervisor ignores it and only notes that the next exit is final — acting on it would exit the parent while the worker was still draining. `SIGTERM` / `SIGHUP` are forwarded explicitly, since they don't propagate to the group on Windows. After any worker exits, the supervisor puts stdin back out of raw mode in case the worker was killed before it could.
+
+`restartDevServer()` returns `false` instead of exiting when there is no supervisor — a programmatic `startDevelopmentServer()` call — so nothing kills a server it can't replace.
+
+### Crash recovery
+
+A worker that dies **after running healthily for at least 5s** — OOM, a native crash, a dead loader thread — is replaced automatically:
+
+```
+14:31:02 Development server was killed by SIGSEGV — restarting.
+```
+
+A worker that dies *sooner* than that failed to **boot** — a broken config, a port already taken — and it has already printed why. Restarting there would just reprint the same error and bury it, so the supervisor mirrors the exit code and stops.
+
+Flapping is capped: more than 3 crashes inside 60s and the supervisor gives up rather than restarting behind your back.
+
+An explicit restart (`r`, `u`, a config change) is a *request*, not a crash, so the uptime rule never swallows it.
+
+### Restart on config change
+
+`warlock.config.ts` and `.env*` are read at boot and feed every config that derives from them, so they cannot be hot-reloaded — a "reload" would leave running services on stale values. When one changes, the dev server restarts itself:
+
+```
+14:22:07 warlock.config.ts changed — restarting to apply.
+```
+
+Set `devServer.restartOnConfigChange: false` for the previous behaviour (a warning telling you to restart yourself). The same warning is printed if a restart is declined or isn't possible, and any ordinary code files that shared the batch still hot-reload normally.
+
 ### What it preloads
 
 ```ts
@@ -67,6 +128,7 @@ export default defineConfig({
     },
     generateTypings: true,             // background type generation
     checkForUpdates: true,             // notify on a newer @warlock.js/core at dev start
+    restartOnConfigChange: true,       // restart when warlock.config.ts / .env* changes
     healthCheckers: [...] /* or false */,
     transpileCacheDebug: false,        // name cache files <slug>.<hash>.js w/ // @source markers
   },
@@ -77,7 +139,8 @@ export default defineConfig({
 - **`generateTypings`** — turn off if you're committing generated typings and don't want them rewritten on every boot. The `--skip-typings` flag is the per-run version.
 - **`healthCheckers`** — custom file health checker contracts (or `false` to disable). The `--skip-health` flag is the per-run version.
 - **`transpileCacheDebug`** — diagnostic only. Names `.warlock/transpile/*.js` files `<slug>.<hash>.js` and appends `// @source <path>` markers so you can eyeball which cache entry came from which source. Leave off in normal use.
-- **`checkForUpdates`** — on `warlock dev` start, check npm for a newer `@warlock.js/core` and print a one-line notice if one exists. Best-effort and non-blocking; auto-skipped in CI and non-TTY shells. Run `warlock update` to upgrade. See [`update-packages/SKILL.md`](../update-packages/SKILL.md).
+- **`checkForUpdates`** — on `warlock dev` start, check npm for a newer `@warlock.js/core` and print a one-line notice if one exists. Best-effort and non-blocking; auto-skipped in CI and non-TTY shells. In an interactive terminal the notice arms a **`u` shortcut** that updates every `@warlock.js/*` package, installs, and restarts the server; elsewhere it prints `npx warlock update` instead. The registry answer is cached for 24h in `.warlock/update-check.json`, so a day of restarts costs one lookup. See [`update-packages/SKILL.md`](../update-packages/SKILL.md).
+- **`restartOnConfigChange`** — restart the dev server when `warlock.config.ts` or any `.env*` changes (default `true`). Set `false` to get a warning instead and restart by hand. Neither file can be hot-reloaded, so without a restart the running services keep the old values.
 
 ## `warlock build` — production bundle
 
@@ -88,7 +151,7 @@ esbuild bundle of the app down to a single JS file in `dist/`. No flags — ever
 ```ts title="warlock.config.ts"
 export default defineConfig({
   build: {
-    outDirectory: "dist",        // default — relative or absolute
+    outdir: "dist",        // default — relative or absolute
     outFile: "app.js",            // default — bundle filename
     minify: true,                 // default — esbuild minify
     sourcemap: true,              // default — true | false | "inline" | "linked"
@@ -98,7 +161,7 @@ export default defineConfig({
 
 Defaults are sensible for the typical "Node service" deployment. Knobs to actually reach for:
 
-- **`outDirectory`** — override when your deployment pipeline expects a different folder (e.g. `build/`, `.build/`).
+- **`outdir`** — override when your deployment pipeline expects a different folder (e.g. `build/`, `.build/`). `outDirectory` is accepted as an alias (the docs used that name for several releases while the code only read `outdir`); `outdir` wins if both are set.
 - **`outFile`** — override when bundling multiple Warlock apps into one image and they need distinct entry filenames.
 - **`minify: false`** — flip to debug a production-only bug. Larger bundle, readable stack traces.
 - **`sourcemap: "inline"`** — embed the source map in the bundle. Useful when your error reporter only captures the bundle and can't fetch a `.map` sidecar.
@@ -111,7 +174,7 @@ Just `warlockConfig: true`. Build doesn't need the app booted — it reads `warl
 ### Where the bundle lands
 
 ```
-<cwd>/<outDirectory>/<outFile>
+<cwd>/<outdir>/<outFile>
 └─ default: <cwd>/dist/app.js
 ```
 
@@ -205,7 +268,7 @@ import { defineConfig, env } from "@warlock.js/core";
 
 export default defineConfig({
   build: {
-    outDirectory: env("BUILD_OUT", "dist"),
+    outdir: env("BUILD_OUT", "dist"),
     outFile: env("BUILD_FILE", "app.js"),
   },
 });
@@ -249,7 +312,7 @@ NODE_OPTIONS=--max-old-space-size=4096 yarn warlock start
 - **`--fresh` only deletes the manifest, not the transpile cache.** If you're chasing a stale-compile bug, `rm -rf .warlock/` clears everything. The manifest restoring is what `--fresh` solves.
 - **`warlock build` does NOT run migrations.** Production bundles ship the migration files but don't apply them. Run `yarn warlock migrate` against the production DB separately.
 - **`warlock start` requires a built bundle.** Run `warlock build` first, or you'll spawn `node` against a non-existent file and crash immediately.
-- **`outDirectory` is the directory, `outFile` is the filename within it.** A common mistake is putting the full path in one and leaving the other default — you end up with `<full-path>/app.js` or `dist/<full-path>`. They concatenate.
+- **`outdir` is the directory, `outFile` is the filename within it.** A common mistake is putting the full path in one and leaving the other default — you end up with `<full-path>/app.js` or `dist/<full-path>`. They concatenate.
 - **`sourcemap: false` cascades to `start`.** Stack traces lose `.ts` precision. Keep sourcemaps on unless artifact size is a hard constraint.
 - **`NODE_ENV` is not set by these commands.** The deployment env (your Dockerfile, CI, hosting provider) sets it. Forget it on a production server and `Application.isProduction` returns `false`, which flips cookie security, CORS, logging — silently. Always set `NODE_ENV=production` in production deployments.
 - **`prestart` runs once on dev boot, not on reload.** If you're seeding test data in `src/app/prestart.ts`, it fires on `warlock dev` startup only. HMR reloads don't re-run it.