@warlock.js/core 5.0.2 → 5.2.0

package/esm/cli/commands/add.command.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"add.command.mjs","names":[],"sources":["../../../../../../../../core/src/cli/commands/add.command.ts"],"sourcesContent":["import { addCommandAction } from \"../../generations/add-command.action\";\r\nimport { command } from \"../../commands/cli-command\";\r\n\r\nexport const addCommand = command({\r\n  name: \"add <features...>\",\r\n  description: \"Add new feature(s) to the project\",\r\n  action: addCommandAction,\r\n  options: [\r\n    {\r\n      text: \"--package-manager -pm\",\r\n      description: \"Package manager to use, if not passed, it will be detected automatically\",\r\n    },\r\n    {\r\n      text: \"--list, -l\",\r\n      description: \"List available features\",\r\n      type: \"boolean\",\r\n    },\r\n    {\r\n      text: \"--no-install\",\r\n      description:\r\n        \"Record dependencies in package.json without installing them — still ejects configs, adds scripts, and runs setup hooks. Used by scaffolders that run a single install afterwards.\",\r\n      type: \"boolean\",\r\n    },\r\n  ],\r\n});\r\n"],"mappings":";;;;AAGA,MAAa,aAAa,QAAQ;CAChC,MAAM;CACN,aAAa;CACb,QAAQ;CACR,SAAS;EACP;GACE,MAAM;GACN,aAAa;EACf;EACA;GACE,MAAM;GACN,aAAa;GACb,MAAM;EACR;EACA;GACE,MAAM;GACN,aACE;GACF,MAAM;EACR;CACF;AACF,CAAC"}
+{"version":3,"file":"add.command.mjs","names":[],"sources":["C:/Work/Warlock.js/core/src/cli/commands/add.command.ts"],"sourcesContent":["import { addCommandAction } from \"../../generations/add-command.action\";\r\nimport { command } from \"../../commands/cli-command\";\r\n\r\nexport const addCommand = command({\r\n  name: \"add <features...>\",\r\n  description: \"Add new feature(s) to the project\",\r\n  action: addCommandAction,\r\n  options: [\r\n    {\r\n      text: \"--package-manager -pm\",\r\n      description: \"Package manager to use, if not passed, it will be detected automatically\",\r\n    },\r\n    {\r\n      text: \"--list, -l\",\r\n      description: \"List available features\",\r\n      type: \"boolean\",\r\n    },\r\n    {\r\n      text: \"--no-install\",\r\n      description:\r\n        \"Record dependencies in package.json without installing them — still ejects configs, adds scripts, and runs setup hooks. Used by scaffolders that run a single install afterwards.\",\r\n      type: \"boolean\",\r\n    },\r\n  ],\r\n});\r\n"],"mappings":";;;;AAGA,MAAa,aAAa,QAAQ;CAChC,MAAM;CACN,aAAa;CACb,QAAQ;CACR,SAAS;EACP;GACE,MAAM;GACN,aAAa;EACf;EACA;GACE,MAAM;GACN,aAAa;GACb,MAAM;EACR;EACA;GACE,MAAM;GACN,aACE;GACF,MAAM;EACR;CACF;AACF,CAAC"}

package/esm/cli/commands/build.command.mjs

@@ -1,7 +1,7 @@
 import { command } from "../../commands/cli-command.mjs";
 import { buildAppProduction } from "../../production/build-app-production.mjs";
 
-//#region ../core/src/cli/commands/build.command.ts
+//#region core/src/cli/commands/build.command.ts
 const buildCommand = command({
 	name: "build",
 	description: "Build the project for production",

package/esm/cli/commands/build.command.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"build.command.mjs","names":[],"sources":["../../../../../../../../core/src/cli/commands/build.command.ts"],"sourcesContent":["import { buildAppProduction } from \"../../production/build-app-production\";\r\nimport { command } from \"../../commands/cli-command\";\r\n\r\nexport const buildCommand = command({\r\n  name: \"build\",\r\n  description: \"Build the project for production\",\r\n  action: buildAppProduction,\r\n  preload: {\r\n    warlockConfig: true,\r\n  },\r\n});\r\n"],"mappings":";;;;AAGA,MAAa,eAAe,QAAQ;CAClC,MAAM;CACN,aAAa;CACb,QAAQ;CACR,SAAS,EACP,eAAe,KACjB;AACF,CAAC"}
+{"version":3,"file":"build.command.mjs","names":[],"sources":["C:/Work/Warlock.js/core/src/cli/commands/build.command.ts"],"sourcesContent":["import { buildAppProduction } from \"../../production/build-app-production\";\r\nimport { command } from \"../../commands/cli-command\";\r\n\r\nexport const buildCommand = command({\r\n  name: \"build\",\r\n  description: \"Build the project for production\",\r\n  action: buildAppProduction,\r\n  preload: {\r\n    warlockConfig: true,\r\n  },\r\n});\r\n"],"mappings":";;;;AAGA,MAAa,eAAe,QAAQ;CAClC,MAAM;CACN,aAAa;CACb,QAAQ;CACR,SAAS,EACP,eAAe,KACjB;AACF,CAAC"}

package/esm/cli/commands/create-database.command.mjs

@@ -1,7 +1,7 @@
 import { command } from "../../commands/cli-command.mjs";
 import { createDatabaseAction } from "../../database/create-database-action.mjs";
 
-//#region ../core/src/cli/commands/create-database.command.ts
+//#region core/src/cli/commands/create-database.command.ts
 const createDatabaseCommand = command({
 	name: "create-database <name>",
 	alias: "cdb",

package/esm/cli/commands/create-database.command.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"create-database.command.mjs","names":[],"sources":["../../../../../../../../core/src/cli/commands/create-database.command.ts"],"sourcesContent":["import { createDatabaseAction } from \"../../database/create-database-action\";\r\nimport { command } from \"../../commands/cli-command\";\r\n\r\nexport const createDatabaseCommand = command({\r\n  name: \"create-database <name>\",\r\n  alias: \"cdb\",\r\n  description: \"Create a new database\",\r\n  action: createDatabaseAction,\r\n  preload: {\r\n    config: [\"database\", \"log\"],\r\n    env: true,\r\n    connectors: [\"database\"],\r\n  },\r\n  options: [\r\n    {\r\n      text: \"--connection, -c\",\r\n      description: \"Database connection name\",\r\n      defaultValue: \"default\",\r\n    },\r\n  ],\r\n});\r\n"],"mappings":";;;;AAGA,MAAa,wBAAwB,QAAQ;CAC3C,MAAM;CACN,OAAO;CACP,aAAa;CACb,QAAQ;CACR,SAAS;EACP,QAAQ,CAAC,YAAY,KAAK;EAC1B,KAAK;EACL,YAAY,CAAC,UAAU;CACzB;CACA,SAAS,CACP;EACE,MAAM;EACN,aAAa;EACb,cAAc;CAChB,CACF;AACF,CAAC"}
+{"version":3,"file":"create-database.command.mjs","names":[],"sources":["C:/Work/Warlock.js/core/src/cli/commands/create-database.command.ts"],"sourcesContent":["import { createDatabaseAction } from \"../../database/create-database-action\";\r\nimport { command } from \"../../commands/cli-command\";\r\n\r\nexport const createDatabaseCommand = command({\r\n  name: \"create-database <name>\",\r\n  alias: \"cdb\",\r\n  description: \"Create a new database\",\r\n  action: createDatabaseAction,\r\n  preload: {\r\n    config: [\"database\", \"log\"],\r\n    env: true,\r\n    connectors: [\"database\"],\r\n  },\r\n  options: [\r\n    {\r\n      text: \"--connection, -c\",\r\n      description: \"Database connection name\",\r\n      defaultValue: \"default\",\r\n    },\r\n  ],\r\n});\r\n"],"mappings":";;;;AAGA,MAAa,wBAAwB,QAAQ;CAC3C,MAAM;CACN,OAAO;CACP,aAAa;CACb,QAAQ;CACR,SAAS;EACP,QAAQ,CAAC,YAAY,KAAK;EAC1B,KAAK;EACL,YAAY,CAAC,UAAU;CACzB;CACA,SAAS,CACP;EACE,MAAM;EACN,aAAa;EACb,cAAc;CAChB,CACF;AACF,CAAC"}

package/esm/cli/commands/dev-server.command.mjs

@@ -1,10 +1,10 @@
 import { command } from "../../commands/cli-command.mjs";
-import { displayStartupBanner } from "../cli-commands.utils.mjs";
 import { isDevWorker, superviseDevServer } from "../../dev-server/supervisor.mjs";
+import { displayStartupBanner } from "../cli-commands.utils.mjs";
 import { checkForFrameworkUpdate } from "../../dev-server/check-for-updates.mjs";
 import { startDevelopmentServer } from "../../dev-server/start-development-server.mjs";
 
-//#region ../core/src/cli/commands/dev-server.command.ts
+//#region core/src/cli/commands/dev-server.command.ts
 const devServerCommand = command({
 	name: "dev",
 	description: "Start development server (HMR, type-gen, health checks)",

package/esm/cli/commands/dev-server.command.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"dev-server.command.mjs","names":[],"sources":["../../../../../../../../core/src/cli/commands/dev-server.command.ts"],"sourcesContent":["import { checkForFrameworkUpdate } from \"../../dev-server/check-for-updates\";\r\nimport { startDevelopmentServer } from \"../../dev-server/start-development-server\";\r\nimport { isDevWorker, superviseDevServer } from \"../../dev-server/supervisor\";\r\nimport { command } from \"../../commands/cli-command\";\r\nimport { displayStartupBanner } from \"../cli-commands.utils\";\r\n\r\nexport const devServerCommand = command({\r\n  name: \"dev\",\r\n  description: \"Start development server (HMR, type-gen, health checks)\",\r\n  persistent: true,\r\n  preload: {\r\n    runtimeStrategy: \"development\",\r\n    // Overrides whatever NODE_ENV the shell exported. A shell with\r\n    // NODE_ENV=production made Vite's dep optimiser pre-bundle the PRODUCTION\r\n    // build of React, which silently suppresses hydration-mismatch warnings —\r\n    // the dev server was hiding the exact class of bug it exists to surface.\r\n    // Set here, in preload, because preloaders run before the action, and the\r\n    // action is what eventually reaches Vite's `createServer`.\r\n    environment: \"development\",\r\n    config: true, // load all config\r\n    bootstrap: true,\r\n    prestart: true, // load prestart file (if exists)\r\n    // Only the Early lifecycle phase starts here; the Late phase\r\n    // (http, socket) starts after app modules load — see\r\n    // development-server.ts STEP 8.5.\r\n    connectors: true,\r\n  },\r\n  preAction: async () => {\r\n    // Two roles share this command. The first `warlock dev` becomes a thin\r\n    // supervisor that owns the terminal and (re)spawns the real server; the\r\n    // process it spawns carries WARLOCK_DEV_WORKER and falls through to the\r\n    // server itself. See supervisor.ts for why the split exists.\r\n    //\r\n    // This branch has to sit in `preAction`, which runs BEFORE the command's\r\n    // preloaders: the supervisor must never load config or start connectors,\r\n    // or it would hold a second database connection open for the whole\r\n    // session. `superviseDevServer()` never resolves, so nothing below it —\r\n    // preload included — runs in the supervisor.\r\n    if (!isDevWorker()) {\r\n      return superviseDevServer();\r\n    }\r\n\r\n    await displayStartupBanner({ environment: \"development\" });\r\n  },\r\n  action: async (data) => {\r\n    const devServer = await startDevelopmentServer({\r\n      fresh: Boolean(data.options.fresh),\r\n      // Pass `false` only when the CLI flag is explicitly set; `undefined`\r\n      // lets `warlock.config.ts > devServer.*` defaults apply.\r\n      generateTypings: data.options.skipTypings ? false : undefined,\r\n      healthCheckers: data.options.skipHealth ? false : undefined,\r\n    });\r\n\r\n    // Fire-and-forget: once the server is ready, surface a one-line notice if\r\n    // a newer @warlock.js/core has been published, and arm the `u` shortcut\r\n    // that updates + restarts. Fully self-guarded — it never blocks startup\r\n    // nor breaks dev if the registry is unreachable.\r\n    void checkForFrameworkUpdate(devServer);\r\n  },\r\n  options: [\r\n    {\r\n      text: \"--fresh, -f\",\r\n      description: \"Delete .warlock/manifest.json before start (force full re-parse from disk)\",\r\n      type: \"boolean\",\r\n    },\r\n    {\r\n      text: \"--skip-typings, -st\",\r\n      description: \"Skip background type generation for this run\",\r\n      type: \"boolean\",\r\n    },\r\n    {\r\n      text: \"--skip-health, -sh\",\r\n      description: \"Skip file health checkers for this run\",\r\n      type: \"boolean\",\r\n    },\r\n  ],\r\n});\r\n"],"mappings":";;;;;;;AAMA,MAAa,mBAAmB,QAAQ;CACtC,MAAM;CACN,aAAa;CACb,YAAY;CACZ,SAAS;EACP,iBAAiB;EAOjB,aAAa;EACb,QAAQ;EACR,WAAW;EACX,UAAU;EAIV,YAAY;CACd;CACA,WAAW,YAAY;EAWrB,IAAI,CAAC,YAAY,GACf,OAAO,mBAAmB;EAG5B,MAAM,qBAAqB,EAAE,aAAa,cAAc,CAAC;CAC3D;CACA,QAAQ,OAAO,SAAS;EAatB,AAAK,wBAAwB,MAZL,uBAAuB;GAC7C,OAAO,QAAQ,KAAK,QAAQ,KAAK;GAGjC,iBAAiB,KAAK,QAAQ,cAAc,QAAQ;GACpD,gBAAgB,KAAK,QAAQ,aAAa,QAAQ;EACpD,CAAC,CAMqC;CACxC;CACA,SAAS;EACP;GACE,MAAM;GACN,aAAa;GACb,MAAM;EACR;EACA;GACE,MAAM;GACN,aAAa;GACb,MAAM;EACR;EACA;GACE,MAAM;GACN,aAAa;GACb,MAAM;EACR;CACF;AACF,CAAC"}
+{"version":3,"file":"dev-server.command.mjs","names":[],"sources":["C:/Work/Warlock.js/core/src/cli/commands/dev-server.command.ts"],"sourcesContent":["import { checkForFrameworkUpdate } from \"../../dev-server/check-for-updates\";\r\nimport { startDevelopmentServer } from \"../../dev-server/start-development-server\";\r\nimport { isDevWorker, superviseDevServer } from \"../../dev-server/supervisor\";\r\nimport { command } from \"../../commands/cli-command\";\r\nimport { displayStartupBanner } from \"../cli-commands.utils\";\r\n\r\nexport const devServerCommand = command({\r\n  name: \"dev\",\r\n  description: \"Start development server (HMR, type-gen, health checks)\",\r\n  persistent: true,\r\n  preload: {\r\n    runtimeStrategy: \"development\",\r\n    // Overrides whatever NODE_ENV the shell exported. A shell with\r\n    // NODE_ENV=production made Vite's dep optimiser pre-bundle the PRODUCTION\r\n    // build of React, which silently suppresses hydration-mismatch warnings —\r\n    // the dev server was hiding the exact class of bug it exists to surface.\r\n    // Set here, in preload, because preloaders run before the action, and the\r\n    // action is what eventually reaches Vite's `createServer`.\r\n    environment: \"development\",\r\n    config: true, // load all config\r\n    bootstrap: true,\r\n    prestart: true, // load prestart file (if exists)\r\n    // Only the Early lifecycle phase starts here; the Late phase\r\n    // (http, socket) starts after app modules load — see\r\n    // development-server.ts STEP 8.5.\r\n    connectors: true,\r\n  },\r\n  preAction: async () => {\r\n    // Two roles share this command. The first `warlock dev` becomes a thin\r\n    // supervisor that owns the terminal and (re)spawns the real server; the\r\n    // process it spawns carries WARLOCK_DEV_WORKER and falls through to the\r\n    // server itself. See supervisor.ts for why the split exists.\r\n    //\r\n    // This branch has to sit in `preAction`, which runs BEFORE the command's\r\n    // preloaders: the supervisor must never load config or start connectors,\r\n    // or it would hold a second database connection open for the whole\r\n    // session. `superviseDevServer()` never resolves, so nothing below it —\r\n    // preload included — runs in the supervisor.\r\n    if (!isDevWorker()) {\r\n      return superviseDevServer();\r\n    }\r\n\r\n    await displayStartupBanner({ environment: \"development\" });\r\n  },\r\n  action: async (data) => {\r\n    const devServer = await startDevelopmentServer({\r\n      fresh: Boolean(data.options.fresh),\r\n      // Pass `false` only when the CLI flag is explicitly set; `undefined`\r\n      // lets `warlock.config.ts > devServer.*` defaults apply.\r\n      generateTypings: data.options.skipTypings ? false : undefined,\r\n      healthCheckers: data.options.skipHealth ? false : undefined,\r\n    });\r\n\r\n    // Fire-and-forget: once the server is ready, surface a one-line notice if\r\n    // a newer @warlock.js/core has been published, and arm the `u` shortcut\r\n    // that updates + restarts. Fully self-guarded — it never blocks startup\r\n    // nor breaks dev if the registry is unreachable.\r\n    void checkForFrameworkUpdate(devServer);\r\n  },\r\n  options: [\r\n    {\r\n      text: \"--fresh, -f\",\r\n      description: \"Delete .warlock/manifest.json before start (force full re-parse from disk)\",\r\n      type: \"boolean\",\r\n    },\r\n    {\r\n      text: \"--skip-typings, -st\",\r\n      description: \"Skip background type generation for this run\",\r\n      type: \"boolean\",\r\n    },\r\n    {\r\n      text: \"--skip-health, -sh\",\r\n      description: \"Skip file health checkers for this run\",\r\n      type: \"boolean\",\r\n    },\r\n  ],\r\n});\r\n"],"mappings":";;;;;;;AAMA,MAAa,mBAAmB,QAAQ;CACtC,MAAM;CACN,aAAa;CACb,YAAY;CACZ,SAAS;EACP,iBAAiB;EAOjB,aAAa;EACb,QAAQ;EACR,WAAW;EACX,UAAU;EAIV,YAAY;CACd;CACA,WAAW,YAAY;EAWrB,IAAI,CAAC,YAAY,GACf,OAAO,mBAAmB;EAG5B,MAAM,qBAAqB,EAAE,aAAa,cAAc,CAAC;CAC3D;CACA,QAAQ,OAAO,SAAS;EAatB,AAAK,wBAAwB,MAZL,uBAAuB;GAC7C,OAAO,QAAQ,KAAK,QAAQ,KAAK;GAGjC,iBAAiB,KAAK,QAAQ,cAAc,QAAQ;GACpD,gBAAgB,KAAK,QAAQ,aAAa,QAAQ;EACpD,CAAC,CAMqC;CACxC;CACA,SAAS;EACP;GACE,MAAM;GACN,aAAa;GACb,MAAM;EACR;EACA;GACE,MAAM;GACN,aAAa;GACb,MAAM;EACR;EACA;GACE,MAAM;GACN,aAAa;GACb,MAAM;EACR;CACF;AACF,CAAC"}

package/esm/cli/commands/doctor/boot-for-diagnostics.mjs

@@ -0,0 +1,207 @@
+import "../../../config/config-getter.mjs";
+import { container } from "../../../container/index.mjs";
+import { router } from "../../../router/router.mjs";
+import { ConnectorLifecyclePhase } from "../../../connectors/types.mjs";
+import { connectorsManager } from "../../../connectors/connectors-manager.mjs";
+import { registerConfiguredConnectors } from "../../../connectors/register-configured-connectors.mjs";
+import { ModuleLoadError } from "../../../dev-server/module-loader.mjs";
+import { filesOrchestrator } from "../../../dev-server/files-orchestrator.mjs";
+
+//#region core/src/cli/commands/doctor/boot-for-diagnostics.ts
+/**
+* @fileoverview The boot pass `warlock doctor` runs before its checks.
+*
+* THE RULE: **doctor boots, it never starts.**
+*
+* The connector contract already splits the two things doctor needs to keep
+* apart. `boot()` is where a connector REGISTERS — the HTTP connector builds a
+* Fastify instance and adds `/health` + `/ready` to it, the web connector
+* installs one route per page on the app router — and `start()` is where it
+* CONNECTS: opens the database, dials the cache, binds the port. Doctor runs
+* every `boot()` and no `start()`, so it sees the exact surface a served app
+* would have while opening no connection and binding no port.
+*
+* That seam is what makes the checks true. Before it existed here, doctor
+* preloaded config and framework bootstrap only: no app module was ever
+* imported, so no route module ever ran, so `routes` reported `0` on an app
+* `warlock dev` served 14 routes for — while `health` reported the endpoints as
+* "registered" from a config flag alone. Two checks, one app, contradictory
+* answers, and the wrong one was the one users acted on.
+*
+* ORDERING mirrors `DevelopmentServer.start()` exactly, because the route
+* surface is order-dependent: early connectors boot, then models (decorator
+* registries the route modules resolve against), then locales/events/mains/
+* routes, then late connectors — which is where `web` turns pages into routes.
+* Get the order wrong and the count is wrong, which is the defect this replaces.
+*
+* NOT read-only in one narrow sense: it imports the app's own modules, so
+* whatever a module does at import time happens. That is unavoidable — routes
+* only exist as the side effect of importing the file that declares them — and
+* it is the same import the dev server performs. It also refreshes
+* `.warlock/manifest.json`, the framework's own file cache. Nothing in the
+* app's data, and no network, is touched.
+*/
+/**
+* The one connector whose `boot()` can bind a port. See {@link shouldSkipBoot}.
+*/
+const SOCKET_CONNECTOR = "socket";
+/**
+* Normalize anything thrown into a one-line message.
+*/
+function messageOf(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/**
+* Whether doctor must refuse to boot this connector, and why.
+*
+* Exactly one case, and it is not a taste call: `SocketConnector.boot()` shares
+* the HTTP connector's raw server when there is one, and CREATES its own —
+* `server.listen(socketConfig.port)` — when there is not. The HTTP connector
+* boots first (lower priority number), so the shared path is what normally
+* happens; an app that configures `socket` without `http` is the exception, and
+* for that app booting socket would make a diagnostic command open a listening
+* port. Detected by asking the container what HTTP actually left behind rather
+* than by re-deriving the condition from config.
+*/
+function shouldSkipBoot(name) {
+	if (name === SOCKET_CONNECTOR && !container.has("http.server")) return "no http connector to share a server with — booting it would bind a port";
+}
+/**
+* Boot every registered connector in one lifecycle phase, isolating failures.
+*
+* A connector that throws on boot is recorded and the loop continues: one bad
+* connector must not hide the rest of the report, and "which connector failed
+* to boot" is itself a finding worth printing.
+*/
+async function bootPhase(phase, connectors) {
+	for (const connector of connectorsManager.list()) {
+		if (connector.lifecyclePhase !== phase) continue;
+		const skipReason = shouldSkipBoot(connector.name);
+		if (skipReason) {
+			connectors.skipped.push({
+				name: connector.name,
+				reason: skipReason
+			});
+			continue;
+		}
+		try {
+			await connector.boot();
+			connectors.booted.push(connector.name);
+		} catch (error) {
+			connectors.failures.push({
+				name: connector.name,
+				message: messageOf(error)
+			});
+		}
+	}
+}
+/**
+* Import every app module the dev server imports at boot, collecting failures
+* instead of letting the first one abort the pass.
+*
+* `loadAll()` is deliberately reused rather than reimplemented: it owns the
+* canonical order (locale → event → main → route) and the `withSourceFile`
+* scoping that gives each route its origin file. It aggregates its failures and
+* throws them at the end, which is exactly the shape needed here — every module
+* is attempted, and one broken route file cannot mask another.
+*/
+async function loadAppModules() {
+	try {
+		await filesOrchestrator.moduleLoader.loadAll();
+		return [];
+	} catch (error) {
+		if (error instanceof AggregateError) return error.errors.map((failure) => {
+			return failure instanceof ModuleLoadError ? {
+				file: failure.file.relativePath,
+				message: messageOf(failure.cause)
+			} : {
+				file: "unknown",
+				message: messageOf(failure)
+			};
+		});
+		return [{
+			file: "unknown",
+			message: messageOf(error)
+		}];
+	}
+}
+/**
+* Eagerly import model files so the decorator-driven registries the route
+* modules resolve names against are populated first — the same reason
+* `DevelopmentServer.autoDiscoverFiles()` exists, and it must keep the same
+* position in the sequence.
+*/
+async function discoverModels() {
+	const failures = [];
+	for (const file of filesOrchestrator.files.values()) {
+		if (file.type !== "model") continue;
+		try {
+			await filesOrchestrator.moduleLoader.loadModule(file, "model");
+		} catch (error) {
+			failures.push({
+				file: file.relativePath,
+				message: error instanceof ModuleLoadError ? messageOf(error.cause) : messageOf(error)
+			});
+		}
+	}
+	return failures;
+}
+/**
+* Run the boot pass and report what it found.
+*
+* Never throws. Every failure mode — a connector array the config manager
+* refuses, a connector that throws on boot, a route module that fails to
+* import — becomes a field on the returned context, which the checks turn into
+* a printed verdict. A diagnostic command that crashes while diagnosing tells
+* the user nothing.
+*/
+async function bootForDiagnostics() {
+	const connectors = {
+		registered: [],
+		configured: [],
+		booted: [],
+		skipped: [],
+		failures: []
+	};
+	const context = {
+		booted: false,
+		routeModules: 0,
+		appRoutes: 0,
+		totalRoutes: 0,
+		moduleFailures: [],
+		connectors
+	};
+	try {
+		await filesOrchestrator.init();
+		await filesOrchestrator.initializeAll();
+		filesOrchestrator.specialFilesCollector.collect(filesOrchestrator.getFiles());
+		context.routeModules = filesOrchestrator.specialFilesCollector.getFilesByType("route").length;
+	} catch (error) {
+		context.moduleFailures.push({
+			file: "src/",
+			message: messageOf(error)
+		});
+		return context;
+	}
+	try {
+		registerConfiguredConnectors();
+	} catch (error) {
+		connectors.registrationError = messageOf(error);
+	}
+	connectors.registered = connectorsManager.list().map((connector) => connector.name);
+	connectors.configured = connectors.registered.filter((name) => {
+		return !connectorsManager.isBuiltInName(name);
+	});
+	await bootPhase("early", connectors);
+	context.moduleFailures.push(...await discoverModels());
+	context.moduleFailures.push(...await loadAppModules());
+	context.appRoutes = router.routeCount();
+	await bootPhase("late", connectors);
+	context.totalRoutes = router.routeCount();
+	context.booted = true;
+	return context;
+}
+
+//#endregion
+export { bootForDiagnostics };
+//# sourceMappingURL=boot-for-diagnostics.mjs.map

package/esm/cli/commands/doctor/boot-for-diagnostics.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"boot-for-diagnostics.mjs","names":[],"sources":["C:/Work/Warlock.js/core/src/cli/commands/doctor/boot-for-diagnostics.ts"],"sourcesContent":["import { config } from \"../../../config/config-getter\";\r\nimport { connectorsManager } from \"../../../connectors/connectors-manager\";\r\nimport { registerConfiguredConnectors } from \"../../../connectors/register-configured-connectors\";\r\nimport { ConnectorLifecyclePhase } from \"../../../connectors/types\";\r\nimport { container } from \"../../../container\";\r\nimport { filesOrchestrator } from \"../../../dev-server/files-orchestrator\";\r\nimport { ModuleLoadError } from \"../../../dev-server/module-loader\";\r\nimport { router } from \"../../../router/router\";\r\nimport type { DoctorBootContext, ModuleFailure } from \"./check.types\";\r\n\r\n/**\r\n * @fileoverview The boot pass `warlock doctor` runs before its checks.\r\n *\r\n * THE RULE: **doctor boots, it never starts.**\r\n *\r\n * The connector contract already splits the two things doctor needs to keep\r\n * apart. `boot()` is where a connector REGISTERS — the HTTP connector builds a\r\n * Fastify instance and adds `/health` + `/ready` to it, the web connector\r\n * installs one route per page on the app router — and `start()` is where it\r\n * CONNECTS: opens the database, dials the cache, binds the port. Doctor runs\r\n * every `boot()` and no `start()`, so it sees the exact surface a served app\r\n * would have while opening no connection and binding no port.\r\n *\r\n * That seam is what makes the checks true. Before it existed here, doctor\r\n * preloaded config and framework bootstrap only: no app module was ever\r\n * imported, so no route module ever ran, so `routes` reported `0` on an app\r\n * `warlock dev` served 14 routes for — while `health` reported the endpoints as\r\n * \"registered\" from a config flag alone. Two checks, one app, contradictory\r\n * answers, and the wrong one was the one users acted on.\r\n *\r\n * ORDERING mirrors `DevelopmentServer.start()` exactly, because the route\r\n * surface is order-dependent: early connectors boot, then models (decorator\r\n * registries the route modules resolve against), then locales/events/mains/\r\n * routes, then late connectors — which is where `web` turns pages into routes.\r\n * Get the order wrong and the count is wrong, which is the defect this replaces.\r\n *\r\n * NOT read-only in one narrow sense: it imports the app's own modules, so\r\n * whatever a module does at import time happens. That is unavoidable — routes\r\n * only exist as the side effect of importing the file that declares them — and\r\n * it is the same import the dev server performs. It also refreshes\r\n * `.warlock/manifest.json`, the framework's own file cache. Nothing in the\r\n * app's data, and no network, is touched.\r\n */\r\n\r\n/**\r\n * The one connector whose `boot()` can bind a port. See {@link shouldSkipBoot}.\r\n */\r\nconst SOCKET_CONNECTOR = \"socket\";\r\n\r\n/**\r\n * Normalize anything thrown into a one-line message.\r\n */\r\nfunction messageOf(error: unknown): string {\r\n  return error instanceof Error ? error.message : String(error);\r\n}\r\n\r\n/**\r\n * Whether doctor must refuse to boot this connector, and why.\r\n *\r\n * Exactly one case, and it is not a taste call: `SocketConnector.boot()` shares\r\n * the HTTP connector's raw server when there is one, and CREATES its own —\r\n * `server.listen(socketConfig.port)` — when there is not. The HTTP connector\r\n * boots first (lower priority number), so the shared path is what normally\r\n * happens; an app that configures `socket` without `http` is the exception, and\r\n * for that app booting socket would make a diagnostic command open a listening\r\n * port. Detected by asking the container what HTTP actually left behind rather\r\n * than by re-deriving the condition from config.\r\n */\r\nfunction shouldSkipBoot(name: string): string | undefined {\r\n  if (name === SOCKET_CONNECTOR && !container.has(\"http.server\")) {\r\n    return \"no http connector to share a server with — booting it would bind a port\";\r\n  }\r\n\r\n  return undefined;\r\n}\r\n\r\n/**\r\n * Boot every registered connector in one lifecycle phase, isolating failures.\r\n *\r\n * A connector that throws on boot is recorded and the loop continues: one bad\r\n * connector must not hide the rest of the report, and \"which connector failed\r\n * to boot\" is itself a finding worth printing.\r\n */\r\nasync function bootPhase(\r\n  phase: ConnectorLifecyclePhase,\r\n  connectors: DoctorBootContext[\"connectors\"],\r\n): Promise<void> {\r\n  for (const connector of connectorsManager.list()) {\r\n    if (connector.lifecyclePhase !== phase) continue;\r\n\r\n    const skipReason = shouldSkipBoot(connector.name);\r\n\r\n    if (skipReason) {\r\n      connectors.skipped.push({ name: connector.name, reason: skipReason });\r\n      continue;\r\n    }\r\n\r\n    try {\r\n      await connector.boot();\r\n      connectors.booted.push(connector.name);\r\n    } catch (error) {\r\n      connectors.failures.push({ name: connector.name, message: messageOf(error) });\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Import every app module the dev server imports at boot, collecting failures\r\n * instead of letting the first one abort the pass.\r\n *\r\n * `loadAll()` is deliberately reused rather than reimplemented: it owns the\r\n * canonical order (locale → event → main → route) and the `withSourceFile`\r\n * scoping that gives each route its origin file. It aggregates its failures and\r\n * throws them at the end, which is exactly the shape needed here — every module\r\n * is attempted, and one broken route file cannot mask another.\r\n */\r\nasync function loadAppModules(): Promise<ModuleFailure[]> {\r\n  try {\r\n    await filesOrchestrator.moduleLoader.loadAll();\r\n    return [];\r\n  } catch (error) {\r\n    if (error instanceof AggregateError) {\r\n      return (error.errors as unknown[]).map((failure) => {\r\n        return failure instanceof ModuleLoadError\r\n          ? { file: failure.file.relativePath, message: messageOf(failure.cause) }\r\n          : { file: \"unknown\", message: messageOf(failure) };\r\n      });\r\n    }\r\n\r\n    return [{ file: \"unknown\", message: messageOf(error) }];\r\n  }\r\n}\r\n\r\n/**\r\n * Eagerly import model files so the decorator-driven registries the route\r\n * modules resolve names against are populated first — the same reason\r\n * `DevelopmentServer.autoDiscoverFiles()` exists, and it must keep the same\r\n * position in the sequence.\r\n */\r\nasync function discoverModels(): Promise<ModuleFailure[]> {\r\n  const failures: ModuleFailure[] = [];\r\n\r\n  for (const file of filesOrchestrator.files.values()) {\r\n    if (file.type !== \"model\") continue;\r\n\r\n    try {\r\n      await filesOrchestrator.moduleLoader.loadModule(file, \"model\");\r\n    } catch (error) {\r\n      failures.push({\r\n        file: file.relativePath,\r\n        message: error instanceof ModuleLoadError ? messageOf(error.cause) : messageOf(error),\r\n      });\r\n    }\r\n  }\r\n\r\n  return failures;\r\n}\r\n\r\n/**\r\n * Run the boot pass and report what it found.\r\n *\r\n * Never throws. Every failure mode — a connector array the config manager\r\n * refuses, a connector that throws on boot, a route module that fails to\r\n * import — becomes a field on the returned context, which the checks turn into\r\n * a printed verdict. A diagnostic command that crashes while diagnosing tells\r\n * the user nothing.\r\n */\r\nexport async function bootForDiagnostics(): Promise<DoctorBootContext> {\r\n  const connectors: DoctorBootContext[\"connectors\"] = {\r\n    registered: [],\r\n    configured: [],\r\n    booted: [],\r\n    skipped: [],\r\n    failures: [],\r\n  };\r\n\r\n  const context: DoctorBootContext = {\r\n    booted: false,\r\n    routeModules: 0,\r\n    appRoutes: 0,\r\n    totalRoutes: 0,\r\n    moduleFailures: [],\r\n    connectors,\r\n  };\r\n\r\n  try {\r\n    // `init()` is idempotent and the preloader already ran it; calling it again\r\n    // costs nothing and keeps this function honest on its own.\r\n    await filesOrchestrator.init();\r\n    await filesOrchestrator.initializeAll();\r\n\r\n    filesOrchestrator.specialFilesCollector.collect(filesOrchestrator.getFiles());\r\n\r\n    context.routeModules = filesOrchestrator.specialFilesCollector.getFilesByType(\"route\").length;\r\n  } catch (error) {\r\n    context.moduleFailures.push({ file: \"src/\", message: messageOf(error) });\r\n\r\n    return context;\r\n  }\r\n\r\n  // The app's own connectors (`warlock.config.ts > connectors`) must be\r\n  // registered before any phase boots, exactly as the dev preloader does it —\r\n  // otherwise doctor would report on the eleven built-ins alone and miss the\r\n  // connector the app actually configured. This is also the call that refuses a\r\n  // duplicate or reserved connector name, so a config that would crash the next\r\n  // real boot is caught here instead.\r\n  try {\r\n    registerConfiguredConnectors();\r\n  } catch (error) {\r\n    connectors.registrationError = messageOf(error);\r\n  }\r\n\r\n  connectors.registered = connectorsManager.list().map((connector) => connector.name);\r\n  connectors.configured = connectors.registered.filter((name) => {\r\n    return !connectorsManager.isBuiltInName(name);\r\n  });\r\n\r\n  await bootPhase(ConnectorLifecyclePhase.Early, connectors);\r\n\r\n  context.moduleFailures.push(...(await discoverModels()));\r\n  context.moduleFailures.push(...(await loadAppModules()));\r\n\r\n  // Snapshot BEFORE the late phase: everything the app's own route modules\r\n  // registered. The difference between this and the total is what connectors\r\n  // contributed (pages, for `web`), and reporting the two separately is what\r\n  // lets a user reconcile doctor's number with the dev server's.\r\n  context.appRoutes = router.routeCount();\r\n\r\n  await bootPhase(ConnectorLifecyclePhase.Late, connectors);\r\n\r\n  context.totalRoutes = router.routeCount();\r\n\r\n  context.booted = true;\r\n\r\n  return context;\r\n}\r\n\r\n/**\r\n * Whether the app declares an HTTP surface at all. Checks that only make sense\r\n * for a served app use this to opt out instead of inventing a verdict.\r\n */\r\nexport function hasHttpConfig(): boolean {\r\n  return Boolean(config.get(\"http\"));\r\n}\r\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CA,MAAM,mBAAmB;;;;AAKzB,SAAS,UAAU,OAAwB;CACzC,OAAO,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;AAC9D;;;;;;;;;;;;;AAcA,SAAS,eAAe,MAAkC;CACxD,IAAI,SAAS,oBAAoB,CAAC,UAAU,IAAI,aAAa,GAC3D,OAAO;AAIX;;;;;;;;AASA,eAAe,UACb,OACA,YACe;CACf,KAAK,MAAM,aAAa,kBAAkB,KAAK,GAAG;EAChD,IAAI,UAAU,mBAAmB,OAAO;EAExC,MAAM,aAAa,eAAe,UAAU,IAAI;EAEhD,IAAI,YAAY;GACd,WAAW,QAAQ,KAAK;IAAE,MAAM,UAAU;IAAM,QAAQ;GAAW,CAAC;GACpE;EACF;EAEA,IAAI;GACF,MAAM,UAAU,KAAK;GACrB,WAAW,OAAO,KAAK,UAAU,IAAI;EACvC,SAAS,OAAO;GACd,WAAW,SAAS,KAAK;IAAE,MAAM,UAAU;IAAM,SAAS,UAAU,KAAK;GAAE,CAAC;EAC9E;CACF;AACF;;;;;;;;;;;AAYA,eAAe,iBAA2C;CACxD,IAAI;EACF,MAAM,kBAAkB,aAAa,QAAQ;EAC7C,OAAO,CAAC;CACV,SAAS,OAAO;EACd,IAAI,iBAAiB,gBACnB,OAAQ,MAAM,OAAqB,KAAK,YAAY;GAClD,OAAO,mBAAmB,kBACtB;IAAE,MAAM,QAAQ,KAAK;IAAc,SAAS,UAAU,QAAQ,KAAK;GAAE,IACrE;IAAE,MAAM;IAAW,SAAS,UAAU,OAAO;GAAE;EACrD,CAAC;EAGH,OAAO,CAAC;GAAE,MAAM;GAAW,SAAS,UAAU,KAAK;EAAE,CAAC;CACxD;AACF;;;;;;;AAQA,eAAe,iBAA2C;CACxD,MAAM,WAA4B,CAAC;CAEnC,KAAK,MAAM,QAAQ,kBAAkB,MAAM,OAAO,GAAG;EACnD,IAAI,KAAK,SAAS,SAAS;EAE3B,IAAI;GACF,MAAM,kBAAkB,aAAa,WAAW,MAAM,OAAO;EAC/D,SAAS,OAAO;GACd,SAAS,KAAK;IACZ,MAAM,KAAK;IACX,SAAS,iBAAiB,kBAAkB,UAAU,MAAM,KAAK,IAAI,UAAU,KAAK;GACtF,CAAC;EACH;CACF;CAEA,OAAO;AACT;;;;;;;;;;AAWA,eAAsB,qBAAiD;CACrE,MAAM,aAA8C;EAClD,YAAY,CAAC;EACb,YAAY,CAAC;EACb,QAAQ,CAAC;EACT,SAAS,CAAC;EACV,UAAU,CAAC;CACb;CAEA,MAAM,UAA6B;EACjC,QAAQ;EACR,cAAc;EACd,WAAW;EACX,aAAa;EACb,gBAAgB,CAAC;EACjB;CACF;CAEA,IAAI;EAGF,MAAM,kBAAkB,KAAK;EAC7B,MAAM,kBAAkB,cAAc;EAEtC,kBAAkB,sBAAsB,QAAQ,kBAAkB,SAAS,CAAC;EAE5E,QAAQ,eAAe,kBAAkB,sBAAsB,eAAe,OAAO,EAAE;CACzF,SAAS,OAAO;EACd,QAAQ,eAAe,KAAK;GAAE,MAAM;GAAQ,SAAS,UAAU,KAAK;EAAE,CAAC;EAEvE,OAAO;CACT;CAQA,IAAI;EACF,6BAA6B;CAC/B,SAAS,OAAO;EACd,WAAW,oBAAoB,UAAU,KAAK;CAChD;CAEA,WAAW,aAAa,kBAAkB,KAAK,EAAE,KAAK,cAAc,UAAU,IAAI;CAClF,WAAW,aAAa,WAAW,WAAW,QAAQ,SAAS;EAC7D,OAAO,CAAC,kBAAkB,cAAc,IAAI;CAC9C,CAAC;CAED,MAAM,mBAAyC,UAAU;CAEzD,QAAQ,eAAe,KAAK,GAAI,MAAM,eAAe,CAAE;CACvD,QAAQ,eAAe,KAAK,GAAI,MAAM,eAAe,CAAE;CAMvD,QAAQ,YAAY,OAAO,WAAW;CAEtC,MAAM,kBAAwC,UAAU;CAExD,QAAQ,cAAc,OAAO,WAAW;CAExC,QAAQ,SAAS;CAEjB,OAAO;AACT"}

package/esm/cli/commands/doctor/checks/config.check.mjs

@@ -1,6 +1,6 @@
 import { config } from "../../../../config/config-getter.mjs";
 
-//#region ../core/src/cli/commands/doctor/checks/config.check.ts
+//#region core/src/cli/commands/doctor/checks/config.check.ts
 /**
 * Config sections that a typical Warlock HTTP application is expected to
 * register. A missing section here is release/runtime-blocking, so absence is
@@ -15,8 +15,11 @@ function isPresent(value) {
 	return value !== null && value !== void 0;
 }
 /**
-* Verifies that the required top-level config sections are present. Reads each
-* section via `config.get` only — never mutates configuration.
+* Verifies that the required top-level config sections are present.
+*
+* NEEDS NO BOOTED APP — config files are loaded by the command's preloaders,
+* before the boot pass. Reads each section via `config.get` only; never mutates
+* configuration.
 */
 const configCheck = {
 	name: "config",

package/esm/cli/commands/doctor/checks/config.check.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"config.check.mjs","names":[],"sources":["../../../../../../../../../../core/src/cli/commands/doctor/checks/config.check.ts"],"sourcesContent":["import { config } from \"../../../../config/config-getter\";\nimport type { DoctorCheck } from \"../check.types\";\n\n/**\n * Config sections that a typical Warlock HTTP application is expected to\n * register. A missing section here is release/runtime-blocking, so absence is\n * a `fail` rather than a warning.\n */\nconst REQUIRED_CONFIG_SECTIONS = [\"app\", \"http\"] as const;\n\n/**\n * `@mongez/config` returns `null` (not `undefined`) for an unregistered key,\n * so treat both nullish values as \"missing\".\n */\nfunction isPresent(value: unknown): boolean {\n  return value !== null && value !== undefined;\n}\n\n/**\n * Verifies that the required top-level config sections are present. Reads each\n * section via `config.get` only — never mutates configuration.\n */\nexport const configCheck: DoctorCheck = {\n  name: \"config\",\n  run: () => {\n    const missing = REQUIRED_CONFIG_SECTIONS.filter((section) => {\n      return !isPresent(config.get(section));\n    });\n\n    if (missing.length > 0) {\n      return {\n        name: \"config\",\n        status: \"fail\",\n        detail: `missing required config section(s): ${missing.join(\", \")}`,\n      };\n    }\n\n    return {\n      name: \"config\",\n      status: \"ok\",\n      detail: `required sections present (${REQUIRED_CONFIG_SECTIONS.join(\", \")})`,\n    };\n  },\n};\n"],"mappings":";;;;;;;;AAQA,MAAM,2BAA2B,CAAC,OAAO,MAAM;;;;;AAM/C,SAAS,UAAU,OAAyB;CAC1C,OAAO,UAAU,QAAQ,UAAU;AACrC;;;;;AAMA,MAAa,cAA2B;CACtC,MAAM;CACN,WAAW;EACT,MAAM,UAAU,yBAAyB,QAAQ,YAAY;GAC3D,OAAO,CAAC,UAAU,OAAO,IAAI,OAAO,CAAC;EACvC,CAAC;EAED,IAAI,QAAQ,SAAS,GACnB,OAAO;GACL,MAAM;GACN,QAAQ;GACR,QAAQ,uCAAuC,QAAQ,KAAK,IAAI;EAClE;EAGF,OAAO;GACL,MAAM;GACN,QAAQ;GACR,QAAQ,8BAA8B,yBAAyB,KAAK,IAAI,EAAE;EAC5E;CACF;AACF"}
+{"version":3,"file":"config.check.mjs","names":[],"sources":["C:/Work/Warlock.js/core/src/cli/commands/doctor/checks/config.check.ts"],"sourcesContent":["import { config } from \"../../../../config/config-getter\";\nimport type { DoctorCheck } from \"../check.types\";\n\n/**\n * Config sections that a typical Warlock HTTP application is expected to\n * register. A missing section here is release/runtime-blocking, so absence is\n * a `fail` rather than a warning.\n */\nconst REQUIRED_CONFIG_SECTIONS = [\"app\", \"http\"] as const;\n\n/**\n * `@mongez/config` returns `null` (not `undefined`) for an unregistered key,\n * so treat both nullish values as \"missing\".\n */\nfunction isPresent(value: unknown): boolean {\n  return value !== null && value !== undefined;\n}\n\n/**\n * Verifies that the required top-level config sections are present.\n *\n * NEEDS NO BOOTED APP — config files are loaded by the command's preloaders,\n * before the boot pass. Reads each section via `config.get` only; never mutates\n * configuration.\n */\nexport const configCheck: DoctorCheck = {\n  name: \"config\",\n  run: () => {\n    const missing = REQUIRED_CONFIG_SECTIONS.filter((section) => {\n      return !isPresent(config.get(section));\n    });\n\n    if (missing.length > 0) {\n      return {\n        name: \"config\",\n        status: \"fail\",\n        detail: `missing required config section(s): ${missing.join(\", \")}`,\n      };\n    }\n\n    return {\n      name: \"config\",\n      status: \"ok\",\n      detail: `required sections present (${REQUIRED_CONFIG_SECTIONS.join(\", \")})`,\n    };\n  },\n};\n"],"mappings":";;;;;;;;AAQA,MAAM,2BAA2B,CAAC,OAAO,MAAM;;;;;AAM/C,SAAS,UAAU,OAAyB;CAC1C,OAAO,UAAU,QAAQ,UAAU;AACrC;;;;;;;;AASA,MAAa,cAA2B;CACtC,MAAM;CACN,WAAW;EACT,MAAM,UAAU,yBAAyB,QAAQ,YAAY;GAC3D,OAAO,CAAC,UAAU,OAAO,IAAI,OAAO,CAAC;EACvC,CAAC;EAED,IAAI,QAAQ,SAAS,GACnB,OAAO;GACL,MAAM;GACN,QAAQ;GACR,QAAQ,uCAAuC,QAAQ,KAAK,IAAI;EAClE;EAGF,OAAO;GACL,MAAM;GACN,QAAQ;GACR,QAAQ,8BAA8B,yBAAyB,KAAK,IAAI,EAAE;EAC5E;CACF;AACF"}

package/esm/cli/commands/doctor/checks/connectors.check.mjs

@@ -1,24 +1,50 @@
-import { connectorsManager } from "../../../../connectors/connectors-manager.mjs";
-
-//#region ../core/src/cli/commands/doctor/checks/connectors.check.ts
+//#region core/src/cli/commands/doctor/checks/connectors.check.ts
 /**
-* Reports which connectors are registered and which are currently active. This
-* is informational: a registered-but-inactive connector is normal (it simply
-* has no config wired), so the check passes as long as the manager can be
-* enumerated and reports its active set.
+* Reports whether the app's connectors survive boot.
+*
+* NEEDS A BOOTED APP: the boot pass runs every connector's `boot()` and no
+* `start()`, and this check reads the outcome.
+*
+* WHAT THIS REPLACED, AND WHY: the previous version printed
+* `11 registered, none active`. Both halves were tautologies. Eleven is the
+* number of built-in connectors the manager constructs when its module is
+* imported — it is the same on every project that has ever existed and says
+* nothing about the app. And "none active" was guaranteed, because `active` is
+* set by `start()` and doctor deliberately never starts anything: the warning
+* could not be absent from a healthy app, so it could not mean anything on a
+* broken one.
+*
+* What is reported instead is a fact that varies with the project and can be
+* wrong: the connectors the app itself configured, and whether each of them
+* boots. A connector that throws on boot is a boot-time crash the user has not
+* hit yet.
 *
-* Read-only: calls `connectorsManager.list()` and each connector's
-* `isActive()` (a pure getter) only.
+* Verdicts:
+* - `warlock.config.ts > connectors` refused (duplicate or reserved name) →
+*   `fail`. The next real boot would throw the same error;
+* - a connector's `boot()` threw → `fail`, named, with the message;
+* - otherwise → `ok`, listing what booted.
 */
 const connectorsCheck = {
 	name: "connectors",
-	run: () => {
-		const connectors = connectorsManager.list();
-		const activeNames = connectors.filter((connector) => connector.isActive()).map((connector) => connector.name);
+	run: (context) => {
+		const { connectors } = context;
+		if (connectors.registrationError) return {
+			name: "connectors",
+			status: "fail",
+			detail: `warlock.config.ts > connectors was refused: ${connectors.registrationError}`
+		};
+		if (connectors.failures.length > 0) return {
+			name: "connectors",
+			status: "fail",
+			detail: `${connectors.failures.length} connector(s) failed to boot:\n` + connectors.failures.map((failure) => `  - ${failure.name}: ${failure.message}`).join("\n")
+		};
+		if (!context.booted) return;
+		const skipped = connectors.skipped.map((entry) => `; skipped ${entry.name} (${entry.reason})`).join("");
 		return {
 			name: "connectors",
 			status: "ok",
-			detail: activeNames.length > 0 ? `${connectors.length} registered, active: ${activeNames.join(", ")}` : `${connectors.length} registered, none active`
+			detail: `all booted without error (${connectors.configured.length > 0 ? `${connectors.configured.join(", ")} from warlock.config.ts + ${connectors.registered.length - connectors.configured.length} built-in` : `${connectors.registered.length} built-in, none configured in warlock.config.ts`})${skipped}`
 		};
 	}
 };

package/esm/cli/commands/doctor/checks/connectors.check.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"connectors.check.mjs","names":[],"sources":["../../../../../../../../../../core/src/cli/commands/doctor/checks/connectors.check.ts"],"sourcesContent":["import { connectorsManager } from \"../../../../connectors/connectors-manager\";\nimport type { DoctorCheck } from \"../check.types\";\n\n/**\n * Reports which connectors are registered and which are currently active. This\n * is informational: a registered-but-inactive connector is normal (it simply\n * has no config wired), so the check passes as long as the manager can be\n * enumerated and reports its active set.\n *\n * Read-only: calls `connectorsManager.list()` and each connector's\n * `isActive()` (a pure getter) only.\n */\nexport const connectorsCheck: DoctorCheck = {\n  name: \"connectors\",\n  run: () => {\n    const connectors = connectorsManager.list();\n    const active = connectors.filter((connector) => connector.isActive());\n    const activeNames = active.map((connector) => connector.name);\n\n    const detail =\n      activeNames.length > 0\n        ? `${connectors.length} registered, active: ${activeNames.join(\", \")}`\n        : `${connectors.length} registered, none active`;\n\n    return {\n      name: \"connectors\",\n      status: \"ok\",\n      detail,\n    };\n  },\n};\n"],"mappings":";;;;;;;;;;;;AAYA,MAAa,kBAA+B;CAC1C,MAAM;CACN,WAAW;EACT,MAAM,aAAa,kBAAkB,KAAK;EAE1C,MAAM,cADS,WAAW,QAAQ,cAAc,UAAU,SAAS,CAC1C,CAAC,CAAC,KAAK,cAAc,UAAU,IAAI;EAO5D,OAAO;GACL,MAAM;GACN,QAAQ;GACR,QAPA,YAAY,SAAS,IACjB,GAAG,WAAW,OAAO,uBAAuB,YAAY,KAAK,IAAI,MACjE,GAAG,WAAW,OAAO;EAM3B;CACF;AACF"}
+{"version":3,"file":"connectors.check.mjs","names":[],"sources":["C:/Work/Warlock.js/core/src/cli/commands/doctor/checks/connectors.check.ts"],"sourcesContent":["import type { DoctorCheck } from \"../check.types\";\n\n/**\n * Reports whether the app's connectors survive boot.\n *\n * NEEDS A BOOTED APP: the boot pass runs every connector's `boot()` and no\n * `start()`, and this check reads the outcome.\n *\n * WHAT THIS REPLACED, AND WHY: the previous version printed\n * `11 registered, none active`. Both halves were tautologies. Eleven is the\n * number of built-in connectors the manager constructs when its module is\n * imported — it is the same on every project that has ever existed and says\n * nothing about the app. And \"none active\" was guaranteed, because `active` is\n * set by `start()` and doctor deliberately never starts anything: the warning\n * could not be absent from a healthy app, so it could not mean anything on a\n * broken one.\n *\n * What is reported instead is a fact that varies with the project and can be\n * wrong: the connectors the app itself configured, and whether each of them\n * boots. A connector that throws on boot is a boot-time crash the user has not\n * hit yet.\n *\n * Verdicts:\n * - `warlock.config.ts > connectors` refused (duplicate or reserved name) →\n *   `fail`. The next real boot would throw the same error;\n * - a connector's `boot()` threw → `fail`, named, with the message;\n * - otherwise → `ok`, listing what booted.\n */\nexport const connectorsCheck: DoctorCheck = {\n  name: \"connectors\",\n  run: (context) => {\n    const { connectors } = context;\n\n    if (connectors.registrationError) {\n      return {\n        name: \"connectors\",\n        status: \"fail\",\n        detail: `warlock.config.ts > connectors was refused: ${connectors.registrationError}`,\n      };\n    }\n\n    if (connectors.failures.length > 0) {\n      return {\n        name: \"connectors\",\n        status: \"fail\",\n        detail:\n          `${connectors.failures.length} connector(s) failed to boot:\\n` +\n          connectors.failures\n            .map((failure) => `  - ${failure.name}: ${failure.message}`)\n            .join(\"\\n\"),\n      };\n    }\n\n    if (!context.booted) {\n      return undefined;\n    }\n\n    const skipped = connectors.skipped\n      .map((entry) => `; skipped ${entry.name} (${entry.reason})`)\n      .join(\"\");\n\n    const configured =\n      connectors.configured.length > 0\n        ? `${connectors.configured.join(\", \")} from warlock.config.ts + ` +\n          `${connectors.registered.length - connectors.configured.length} built-in`\n        : `${connectors.registered.length} built-in, none configured in warlock.config.ts`;\n\n    return {\n      name: \"connectors\",\n      status: \"ok\",\n      detail: `all booted without error (${configured})${skipped}`,\n    };\n  },\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,MAAa,kBAA+B;CAC1C,MAAM;CACN,MAAM,YAAY;EAChB,MAAM,EAAE,eAAe;EAEvB,IAAI,WAAW,mBACb,OAAO;GACL,MAAM;GACN,QAAQ;GACR,QAAQ,+CAA+C,WAAW;EACpE;EAGF,IAAI,WAAW,SAAS,SAAS,GAC/B,OAAO;GACL,MAAM;GACN,QAAQ;GACR,QACE,GAAG,WAAW,SAAS,OAAO,mCAC9B,WAAW,SACR,KAAK,YAAY,OAAO,QAAQ,KAAK,IAAI,QAAQ,SAAS,EAC1D,KAAK,IAAI;EAChB;EAGF,IAAI,CAAC,QAAQ,QACX;EAGF,MAAM,UAAU,WAAW,QACxB,KAAK,UAAU,aAAa,MAAM,KAAK,IAAI,MAAM,OAAO,EAAE,EAC1D,KAAK,EAAE;EAQV,OAAO;GACL,MAAM;GACN,QAAQ;GACR,QAAQ,6BARR,WAAW,WAAW,SAAS,IAC3B,GAAG,WAAW,WAAW,KAAK,IAAI,EAAE,4BACjC,WAAW,WAAW,SAAS,WAAW,WAAW,OAAO,aAC/D,GAAG,WAAW,WAAW,OAAO,iDAKY,GAAG;EACrD;CACF;AACF"}

package/esm/cli/commands/doctor/checks/handler-signature.check.mjs

@@ -1,6 +1,6 @@
 import { describePositionalHandlerSuspect, listPositionalHandlerSuspects } from "../../../../router/positional-handler-diagnostics.mjs";
 
-//#region ../core/src/cli/commands/doctor/checks/handler-signature.check.ts
+//#region core/src/cli/commands/doctor/checks/handler-signature.check.ts
 /**
 * Surfaces route handlers still written against the v4 positional signature,
 * `(request, response)`. v5 calls a handler with a single context object, so
@@ -14,13 +14,17 @@ import { describePositionalHandlerSuspect, listPositionalHandlerSuspects } from
 * `warn`, never `fail`: the detection is a heuristic on the handler's declared
 * parameters, so a false positive is possible and must not break a build.
 *
-* Read-only: reads the list the router collected while routes registered. It
-* therefore reports on the routes this process has loaded — a run before route
-* registration sees nothing.
+* NEEDS A BOOTED APP: the router collects suspects as routes register, so this
+* reads a list the boot pass filled. Before that pass existed the list was
+* always empty and this check always passed — it was green because it had
+* nothing to look at, which is indistinguishable from green because the app is
+* fine. It stays silent when there are no routes for the same reason: a check
+* with no input reports nothing rather than a clean bill of health.
 */
 const handlerSignatureCheck = {
 	name: "handler-signature",
-	run: () => {
+	run: (context) => {
+		if (context.totalRoutes === 0) return;
 		const suspects = listPositionalHandlerSuspects();
 		if (suspects.length === 0) return {
 			name: "handler-signature",

package/esm/cli/commands/doctor/checks/handler-signature.check.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"handler-signature.check.mjs","names":[],"sources":["../../../../../../../../../../core/src/cli/commands/doctor/checks/handler-signature.check.ts"],"sourcesContent":["import {\n  describePositionalHandlerSuspect,\n  listPositionalHandlerSuspects,\n} from \"../../../../router/positional-handler-diagnostics\";\nimport type { DoctorCheck } from \"../check.types\";\n\n/**\n * Surfaces route handlers still written against the v4 positional signature,\n * `(request, response)`. v5 calls a handler with a single context object, so\n * the second parameter is always `undefined` and the route fails on its first\n * request with a `TypeError` that names nothing.\n *\n * Verdicts:\n * - one or more suspects → `warn`;\n * - otherwise → `ok`.\n *\n * `warn`, never `fail`: the detection is a heuristic on the handler's declared\n * parameters, so a false positive is possible and must not break a build.\n *\n * Read-only: reads the list the router collected while routes registered. It\n * therefore reports on the routes this process has loaded — a run before route\n * registration sees nothing.\n */\nexport const handlerSignatureCheck: DoctorCheck = {\n  name: \"handler-signature\",\n  run: () => {\n    const suspects = listPositionalHandlerSuspects();\n\n    if (suspects.length === 0) {\n      return {\n        name: \"handler-signature\",\n        status: \"ok\",\n        detail: \"no handlers look like the v4 positional signature\",\n      };\n    }\n\n    const headline =\n      suspects.length === 1\n        ? \"1 handler looks like the v4 positional signature\"\n        : `${suspects.length} handlers look like the v4 positional signature`;\n\n    return {\n      name: \"handler-signature\",\n      status: \"warn\",\n      detail:\n        `${headline}:\\n` +\n        suspects.map((suspect) => `  - ${describePositionalHandlerSuspect(suspect)}`).join(\"\\n\"),\n    };\n  },\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAuBA,MAAa,wBAAqC;CAChD,MAAM;CACN,WAAW;EACT,MAAM,WAAW,8BAA8B;EAE/C,IAAI,SAAS,WAAW,GACtB,OAAO;GACL,MAAM;GACN,QAAQ;GACR,QAAQ;EACV;EAQF,OAAO;GACL,MAAM;GACN,QAAQ;GACR,QACE,GARF,SAAS,WAAW,IAChB,qDACA,GAAG,SAAS,OAAO,iDAMT,OACZ,SAAS,KAAK,YAAY,OAAO,iCAAiC,OAAO,GAAG,CAAC,CAAC,KAAK,IAAI;EAC3F;CACF;AACF"}
+{"version":3,"file":"handler-signature.check.mjs","names":[],"sources":["C:/Work/Warlock.js/core/src/cli/commands/doctor/checks/handler-signature.check.ts"],"sourcesContent":["import {\n  describePositionalHandlerSuspect,\n  listPositionalHandlerSuspects,\n} from \"../../../../router/positional-handler-diagnostics\";\nimport type { DoctorCheck } from \"../check.types\";\n\n/**\n * Surfaces route handlers still written against the v4 positional signature,\n * `(request, response)`. v5 calls a handler with a single context object, so\n * the second parameter is always `undefined` and the route fails on its first\n * request with a `TypeError` that names nothing.\n *\n * Verdicts:\n * - one or more suspects → `warn`;\n * - otherwise → `ok`.\n *\n * `warn`, never `fail`: the detection is a heuristic on the handler's declared\n * parameters, so a false positive is possible and must not break a build.\n *\n * NEEDS A BOOTED APP: the router collects suspects as routes register, so this\n * reads a list the boot pass filled. Before that pass existed the list was\n * always empty and this check always passed — it was green because it had\n * nothing to look at, which is indistinguishable from green because the app is\n * fine. It stays silent when there are no routes for the same reason: a check\n * with no input reports nothing rather than a clean bill of health.\n */\nexport const handlerSignatureCheck: DoctorCheck = {\n  name: \"handler-signature\",\n  run: (context) => {\n    if (context.totalRoutes === 0) {\n      return undefined;\n    }\n\n    const suspects = listPositionalHandlerSuspects();\n\n    if (suspects.length === 0) {\n      return {\n        name: \"handler-signature\",\n        status: \"ok\",\n        detail: \"no handlers look like the v4 positional signature\",\n      };\n    }\n\n    const headline =\n      suspects.length === 1\n        ? \"1 handler looks like the v4 positional signature\"\n        : `${suspects.length} handlers look like the v4 positional signature`;\n\n    return {\n      name: \"handler-signature\",\n      status: \"warn\",\n      detail:\n        `${headline}:\\n` +\n        suspects.map((suspect) => `  - ${describePositionalHandlerSuspect(suspect)}`).join(\"\\n\"),\n    };\n  },\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA0BA,MAAa,wBAAqC;CAChD,MAAM;CACN,MAAM,YAAY;EAChB,IAAI,QAAQ,gBAAgB,GAC1B;EAGF,MAAM,WAAW,8BAA8B;EAE/C,IAAI,SAAS,WAAW,GACtB,OAAO;GACL,MAAM;GACN,QAAQ;GACR,QAAQ;EACV;EAQF,OAAO;GACL,MAAM;GACN,QAAQ;GACR,QACE,GARF,SAAS,WAAW,IAChB,qDACA,GAAG,SAAS,OAAO,iDAMT,OACZ,SAAS,KAAK,YAAY,OAAO,iCAAiC,OAAO,GAAG,EAAE,KAAK,IAAI;EAC3F;CACF;AACF"}

package/esm/cli/commands/doctor/checks/health.check.mjs

@@ -1,31 +1,97 @@
 import { config } from "../../../../config/config-getter.mjs";
+import { container } from "../../../../container/index.mjs";
+import { router } from "../../../../router/router.mjs";
 
-//#region ../core/src/cli/commands/doctor/checks/health.check.ts
+//#region core/src/cli/commands/doctor/checks/health.check.ts
 /**
-* Confirms the built-in liveness (`/health`) and readiness (`/ready`)
-* endpoints will be exposed. The HTTP connector registers them automatically
-* unless `http.health.enabled` is explicitly `false`, so this check reads that
-* config flag and the (overridable) paths.
+* Ask the booted Fastify instance whether a GET route exists at this path.
 *
-* Disabling the probes is a deliberate, supported choice but a common
-* misconfiguration in container/orchestrated deployments, so it is surfaced as
-* a `warn` rather than a pass.
+* `hasRoute` is the instance's own answer, not a re-derivation of the config
+* that was supposed to produce it — which is the entire point of asking it.
+* Guarded because it is the one part of this check that depends on a Fastify
+* API: if the instance cannot answer, the check says so instead of inventing a
+* verdict from the config flag it is meant to be verifying.
+*/
+function fastifyHasGet(path) {
+	const http = container.has("http.server") ? container.get("http.server") : void 0;
+	if (!http || typeof http.hasRoute !== "function") return void 0;
+	try {
+		return Boolean(http.hasRoute({
+			method: "GET",
+			url: path
+		}));
+	} catch {
+		return;
+	}
+}
+/**
+* Whether an app route already claims this path. The HTTP connector puts the
+* probes on the Fastify instance directly and the router scans app routes onto
+* the same instance at `start()`, so a collision is a duplicate registration:
+* Fastify refuses it and the server does not start.
+*/
+function appRouteClaims(path) {
+	return router.list().some((route) => {
+		const method = String(route.method).toUpperCase();
+		return route.path === path && (method === "GET" || method === "ALL");
+	});
+}
+/**
+* Confirms the liveness (`/health`) and readiness (`/ready`) endpoints are
+* really there.
+*
+* NEEDS A BOOTED APP: the HTTP connector registers the probes during `boot()`,
+* which the boot pass runs. Previously this check read `http.health.enabled`
+* and reported the endpoints as "registered" on that basis alone — in the same
+* report where `routes` said zero, because nothing had been booted at all. It
+* was reporting an intention as a fact, and the two lines contradicted each
+* other in the owner's own run.
 *
-* Read-only: inspects `config.get("http.health")` only.
+* Verdicts:
+* - no `http` config → not applicable, no line;
+* - `http.health.enabled = false` → `ok`. Turning the probes off is a supported
+*   choice, and a warning that fires on a deliberate setting every single run
+*   is not read by the time it matters;
+* - an app route already claims a probe's path → `fail`: Fastify will refuse
+*   the duplicate and the server will not start;
+* - the instance says the route is absent → `fail`;
+* - otherwise → `ok`, with the paths that are actually registered.
 */
 const healthCheck = {
 	name: "health",
-	run: () => {
+	run: (context) => {
+		if (!config.get("http")) return;
 		const healthConfig = config.get("http.health");
 		if (healthConfig?.enabled === false) return {
+			name: "health",
+			status: "ok",
+			detail: "probes disabled by config (http.health.enabled = false)"
+		};
+		const livenessPath = healthConfig?.path ?? "/health";
+		const readinessPath = healthConfig?.readinessPath ?? "/ready";
+		const collisions = [livenessPath, readinessPath].filter(appRouteClaims);
+		if (collisions.length > 0) return {
+			name: "health",
+			status: "fail",
+			detail: `an app route already claims ${collisions.join(" and ")} — Fastify refuses the duplicate registration and the server will not start. Move the app route, or rename the probe via http.health.path / http.health.readinessPath`
+		};
+		if (!context.connectors.booted.includes("http")) return;
+		const registered = [livenessPath, readinessPath].map(fastifyHasGet);
+		if (registered.some((answer) => answer === void 0)) return {
 			name: "health",
 			status: "warn",
-			detail: "health endpoints disabled (http.health.enabled = false)"
+			detail: `could not read the http server's route table — ${livenessPath} + ${readinessPath} unverified`
+		};
+		const missing = [livenessPath, readinessPath].filter((_path, index) => !registered[index]);
+		if (missing.length > 0) return {
+			name: "health",
+			status: "fail",
+			detail: `enabled in config but not registered on the http server: ${missing.join(", ")}`
 		};
 		return {
 			name: "health",
 			status: "ok",
-			detail: `liveness ${healthConfig?.path ?? "/health"} + readiness ${healthConfig?.readinessPath ?? "/ready"} registered`
+			detail: `liveness ${livenessPath} + readiness ${readinessPath} registered`
 		};
 	}
 };