@warlock.js/core 5.0.2 → 5.2.0

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

@@ -1 +1 @@
-{"version":3,"file":"health.check.mjs","names":[],"sources":["../../../../../../../../../../core/src/cli/commands/doctor/checks/health.check.ts"],"sourcesContent":["import { config } from \"../../../../config/config-getter\";\nimport type { DoctorCheck } from \"../check.types\";\n\n/**\n * Confirms the built-in liveness (`/health`) and readiness (`/ready`)\n * endpoints will be exposed. The HTTP connector registers them automatically\n * unless `http.health.enabled` is explicitly `false`, so this check reads that\n * config flag and the (overridable) paths.\n *\n * Disabling the probes is a deliberate, supported choice but a common\n * misconfiguration in container/orchestrated deployments, so it is surfaced as\n * a `warn` rather than a pass.\n *\n * Read-only: inspects `config.get(\"http.health\")` only.\n */\nexport const healthCheck: DoctorCheck = {\n  name: \"health\",\n  run: () => {\n    const healthConfig = config.get(\"http.health\");\n\n    if (healthConfig?.enabled === false) {\n      return {\n        name: \"health\",\n        status: \"warn\",\n        detail: \"health endpoints disabled (http.health.enabled = false)\",\n      };\n    }\n\n    const livenessPath = healthConfig?.path ?? \"/health\";\n    const readinessPath = healthConfig?.readinessPath ?? \"/ready\";\n\n    return {\n      name: \"health\",\n      status: \"ok\",\n      detail: `liveness ${livenessPath} + readiness ${readinessPath} registered`,\n    };\n  },\n};\n"],"mappings":";;;;;;;;;;;;;;;AAeA,MAAa,cAA2B;CACtC,MAAM;CACN,WAAW;EACT,MAAM,eAAe,OAAO,IAAI,aAAa;EAE7C,IAAI,cAAc,YAAY,OAC5B,OAAO;GACL,MAAM;GACN,QAAQ;GACR,QAAQ;EACV;EAMF,OAAO;GACL,MAAM;GACN,QAAQ;GACR,QAAQ,YANW,cAAc,QAAQ,UAMR,eALb,cAAc,iBAAiB,SAKW;EAChE;CACF;AACF"}
+{"version":3,"file":"health.check.mjs","names":[],"sources":["C:/Work/Warlock.js/core/src/cli/commands/doctor/checks/health.check.ts"],"sourcesContent":["import { config } from \"../../../../config/config-getter\";\nimport { container } from \"../../../../container\";\nimport { router } from \"../../../../router/router\";\nimport type { DoctorCheck } from \"../check.types\";\n\n/**\n * Ask the booted Fastify instance whether a GET route exists at this path.\n *\n * `hasRoute` is the instance's own answer, not a re-derivation of the config\n * that was supposed to produce it — which is the entire point of asking it.\n * Guarded because it is the one part of this check that depends on a Fastify\n * API: if the instance cannot answer, the check says so instead of inventing a\n * verdict from the config flag it is meant to be verifying.\n */\nfunction fastifyHasGet(path: string): boolean | undefined {\n  const http = container.has(\"http.server\") ? container.get<any>(\"http.server\") : undefined;\n\n  if (!http || typeof http.hasRoute !== \"function\") return undefined;\n\n  try {\n    return Boolean(http.hasRoute({ method: \"GET\", url: path }));\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Whether an app route already claims this path. The HTTP connector puts the\n * probes on the Fastify instance directly and the router scans app routes onto\n * the same instance at `start()`, so a collision is a duplicate registration:\n * Fastify refuses it and the server does not start.\n */\nfunction appRouteClaims(path: string): boolean {\n  return router.list().some((route) => {\n    const method = String(route.method).toUpperCase();\n\n    return route.path === path && (method === \"GET\" || method === \"ALL\");\n  });\n}\n\n/**\n * Confirms the liveness (`/health`) and readiness (`/ready`) endpoints are\n * really there.\n *\n * NEEDS A BOOTED APP: the HTTP connector registers the probes during `boot()`,\n * which the boot pass runs. Previously this check read `http.health.enabled`\n * and reported the endpoints as \"registered\" on that basis alone — in the same\n * report where `routes` said zero, because nothing had been booted at all. It\n * was reporting an intention as a fact, and the two lines contradicted each\n * other in the owner's own run.\n *\n * Verdicts:\n * - no `http` config → not applicable, no line;\n * - `http.health.enabled = false` → `ok`. Turning the probes off is a supported\n *   choice, and a warning that fires on a deliberate setting every single run\n *   is not read by the time it matters;\n * - an app route already claims a probe's path → `fail`: Fastify will refuse\n *   the duplicate and the server will not start;\n * - the instance says the route is absent → `fail`;\n * - otherwise → `ok`, with the paths that are actually registered.\n */\nexport const healthCheck: DoctorCheck = {\n  name: \"health\",\n  run: (context) => {\n    if (!config.get(\"http\")) {\n      return undefined;\n    }\n\n    const healthConfig = config.get(\"http.health\");\n\n    if (healthConfig?.enabled === false) {\n      return {\n        name: \"health\",\n        status: \"ok\",\n        detail: \"probes disabled by config (http.health.enabled = false)\",\n      };\n    }\n\n    const livenessPath = healthConfig?.path ?? \"/health\";\n    const readinessPath = healthConfig?.readinessPath ?? \"/ready\";\n\n    const collisions = [livenessPath, readinessPath].filter(appRouteClaims);\n\n    if (collisions.length > 0) {\n      return {\n        name: \"health\",\n        status: \"fail\",\n        detail:\n          `an app route already claims ${collisions.join(\" and \")} — Fastify refuses the ` +\n          \"duplicate registration and the server will not start. Move the app route, or \" +\n          \"rename the probe via http.health.path / http.health.readinessPath\",\n      };\n    }\n\n    // The HTTP connector is what registers the probes. If it did not boot, the\n    // connectors check already says so with the reason — reporting the same\n    // defect a second time here as a health failure would inflate one problem\n    // into two.\n    if (!context.connectors.booted.includes(\"http\")) {\n      return undefined;\n    }\n\n    const registered = [livenessPath, readinessPath].map(fastifyHasGet);\n\n    if (registered.some((answer) => answer === undefined)) {\n      return {\n        name: \"health\",\n        status: \"warn\",\n        detail:\n          \"could not read the http server's route table — \" +\n          `${livenessPath} + ${readinessPath} unverified`,\n      };\n    }\n\n    const missing = [livenessPath, readinessPath].filter((_path, index) => !registered[index]);\n\n    if (missing.length > 0) {\n      return {\n        name: \"health\",\n        status: \"fail\",\n        detail: `enabled in config but not registered on the http server: ${missing.join(\", \")}`,\n      };\n    }\n\n    return {\n      name: \"health\",\n      status: \"ok\",\n      detail: `liveness ${livenessPath} + readiness ${readinessPath} registered`,\n    };\n  },\n};\n"],"mappings":";;;;;;;;;;;;;;AAcA,SAAS,cAAc,MAAmC;CACxD,MAAM,OAAO,UAAU,IAAI,aAAa,IAAI,UAAU,IAAS,aAAa,IAAI;CAEhF,IAAI,CAAC,QAAQ,OAAO,KAAK,aAAa,YAAY,OAAO;CAEzD,IAAI;EACF,OAAO,QAAQ,KAAK,SAAS;GAAE,QAAQ;GAAO,KAAK;EAAK,CAAC,CAAC;CAC5D,QAAQ;EACN;CACF;AACF;;;;;;;AAQA,SAAS,eAAe,MAAuB;CAC7C,OAAO,OAAO,KAAK,EAAE,MAAM,UAAU;EACnC,MAAM,SAAS,OAAO,MAAM,MAAM,EAAE,YAAY;EAEhD,OAAO,MAAM,SAAS,SAAS,WAAW,SAAS,WAAW;CAChE,CAAC;AACH;;;;;;;;;;;;;;;;;;;;;;AAuBA,MAAa,cAA2B;CACtC,MAAM;CACN,MAAM,YAAY;EAChB,IAAI,CAAC,OAAO,IAAI,MAAM,GACpB;EAGF,MAAM,eAAe,OAAO,IAAI,aAAa;EAE7C,IAAI,cAAc,YAAY,OAC5B,OAAO;GACL,MAAM;GACN,QAAQ;GACR,QAAQ;EACV;EAGF,MAAM,eAAe,cAAc,QAAQ;EAC3C,MAAM,gBAAgB,cAAc,iBAAiB;EAErD,MAAM,aAAa,CAAC,cAAc,aAAa,EAAE,OAAO,cAAc;EAEtE,IAAI,WAAW,SAAS,GACtB,OAAO;GACL,MAAM;GACN,QAAQ;GACR,QACE,+BAA+B,WAAW,KAAK,OAAO,EAAE;EAG5D;EAOF,IAAI,CAAC,QAAQ,WAAW,OAAO,SAAS,MAAM,GAC5C;EAGF,MAAM,aAAa,CAAC,cAAc,aAAa,EAAE,IAAI,aAAa;EAElE,IAAI,WAAW,MAAM,WAAW,WAAW,MAAS,GAClD,OAAO;GACL,MAAM;GACN,QAAQ;GACR,QACE,kDACG,aAAa,KAAK,cAAc;EACvC;EAGF,MAAM,UAAU,CAAC,cAAc,aAAa,EAAE,QAAQ,OAAO,UAAU,CAAC,WAAW,MAAM;EAEzF,IAAI,QAAQ,SAAS,GACnB,OAAO;GACL,MAAM;GACN,QAAQ;GACR,QAAQ,4DAA4D,QAAQ,KAAK,IAAI;EACvF;EAGF,OAAO;GACL,MAAM;GACN,QAAQ;GACR,QAAQ,YAAY,aAAa,eAAe,cAAc;EAChE;CACF;AACF"}

package/esm/cli/commands/doctor/checks/index.mjs

@@ -6,11 +6,16 @@ import { optionalPeersCheck } from "./optional-peers.check.mjs";
 import { releaseHygieneCheck } from "./release-hygiene.check.mjs";
 import { routesCheck } from "./routes.check.mjs";
 
-//#region ../core/src/cli/commands/doctor/checks/index.ts
+//#region core/src/cli/commands/doctor/checks/index.ts
 /**
 * The default, ordered set of checks `warlock doctor` runs. Ordering controls
 * the report layout: runtime-surface checks first (routes, handler signatures,
 * config, connectors, peers, health), release hygiene last.
+*
+* Every check is handed the same boot context, and any of them may return
+* `undefined` to opt out of a project it does not apply to — so this list is
+* the set of checks that COULD run, not the set of lines a given project will
+* print.
 */
 const defaultDoctorChecks = [
 	routesCheck,

package/esm/cli/commands/doctor/checks/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../../../../../../../../../../core/src/cli/commands/doctor/checks/index.ts"],"sourcesContent":["import type { DoctorCheck } from \"../check.types\";\nimport { configCheck } from \"./config.check\";\nimport { connectorsCheck } from \"./connectors.check\";\nimport { handlerSignatureCheck } from \"./handler-signature.check\";\nimport { healthCheck } from \"./health.check\";\nimport { optionalPeersCheck } from \"./optional-peers.check\";\nimport { releaseHygieneCheck } from \"./release-hygiene.check\";\nimport { routesCheck } from \"./routes.check\";\n\n/**\n * The default, ordered set of checks `warlock doctor` runs. Ordering controls\n * the report layout: runtime-surface checks first (routes, handler signatures,\n * config, connectors, peers, health), release hygiene last.\n */\nexport const defaultDoctorChecks: DoctorCheck[] = [\n  routesCheck,\n  handlerSignatureCheck,\n  configCheck,\n  connectorsCheck,\n  optionalPeersCheck,\n  healthCheck,\n  releaseHygieneCheck,\n];\n"],"mappings":";;;;;;;;;;;;;;AAcA,MAAa,sBAAqC;CAChD;CACA;CACA;CACA;CACA;CACA;CACA;AACF"}
+{"version":3,"file":"index.mjs","names":[],"sources":["C:/Work/Warlock.js/core/src/cli/commands/doctor/checks/index.ts"],"sourcesContent":["import type { DoctorCheck } from \"../check.types\";\nimport { configCheck } from \"./config.check\";\nimport { connectorsCheck } from \"./connectors.check\";\nimport { handlerSignatureCheck } from \"./handler-signature.check\";\nimport { healthCheck } from \"./health.check\";\nimport { optionalPeersCheck } from \"./optional-peers.check\";\nimport { releaseHygieneCheck } from \"./release-hygiene.check\";\nimport { routesCheck } from \"./routes.check\";\n\n/**\n * The default, ordered set of checks `warlock doctor` runs. Ordering controls\n * the report layout: runtime-surface checks first (routes, handler signatures,\n * config, connectors, peers, health), release hygiene last.\n *\n * Every check is handed the same boot context, and any of them may return\n * `undefined` to opt out of a project it does not apply to — so this list is\n * the set of checks that COULD run, not the set of lines a given project will\n * print.\n */\nexport const defaultDoctorChecks: DoctorCheck[] = [\n  routesCheck,\n  handlerSignatureCheck,\n  configCheck,\n  connectorsCheck,\n  optionalPeersCheck,\n  healthCheck,\n  releaseHygieneCheck,\n];\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAmBA,MAAa,sBAAqC;CAChD;CACA;CACA;CACA;CACA;CACA;CACA;AACF"}

package/esm/cli/commands/doctor/checks/optional-peers.check.mjs

@@ -1,49 +1,7 @@
+import { config } from "../../../../config/config-getter.mjs";
 import { createRequire } from "node:module";
 
-//#region ../core/src/cli/commands/doctor/checks/optional-peers.check.ts
-/**
-* The optional peers core knows how to use. Kept in sync with the install
-* targets in the `warlock add` feature registry (sharp, nodemailer, socket.io,
-* the AWS SDK family, redis, the Cascade DB drivers, …).
-*/
-const OPTIONAL_PEERS = [
-	{
-		package: "sharp",
-		feature: "image processing"
-	},
-	{
-		package: "nodemailer",
-		feature: "mail (SMTP) channel"
-	},
-	{
-		package: "socket.io",
-		feature: "realtime socket server"
-	},
-	{
-		package: "@aws-sdk/client-s3",
-		feature: "S3 cloud storage"
-	},
-	{
-		package: "@aws-sdk/client-sesv2",
-		feature: "Amazon SES mail channel"
-	},
-	{
-		package: "redis",
-		feature: "Redis cache driver"
-	},
-	{
-		package: "mongodb",
-		feature: "MongoDB database driver"
-	},
-	{
-		package: "pg",
-		feature: "Postgres database driver"
-	},
-	{
-		package: "mysql2",
-		feature: "MySQL database driver"
-	}
-];
+//#region core/src/cli/commands/doctor/checks/optional-peers.check.ts
 /**
 * Resolve from the project's working directory, not from core's own
 * `node_modules`, so the probe reflects what the *consuming app* has installed.
@@ -62,25 +20,130 @@ function isInstalled(packageName) {
 	}
 }
 /**
-* Detects which optional peer dependencies are installed and which are not,
-* reporting the features that are consequently unavailable. Missing peers are
-* a `warn` (the feature is simply off), never a `fail`.
+* A non-empty string, or `undefined`. Config values arrive from `env(...)` and
+* an unset variable yields `undefined` — but a `.env` line with nothing after
+* the `=` yields `""`, which is "not configured" just as much.
+*/
+function text(value) {
+	return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+/**
+* The database driver's package. `driver` is a closed union in cascade
+* (`mongodb | postgres | mysql`), so an unrecognised value means the config is
+* wrong in a way this check is not the right one to report.
+*/
+function databasePeer() {
+	const driver = text(config.get("database.driver"));
+	const packageName = driver === "mongodb" ? "mongodb" : driver === "postgres" ? "pg" : driver === "mysql" ? "mysql2" : void 0;
+	return packageName ? {
+		package: packageName,
+		because: `database.driver = "${driver}"`
+	} : void 0;
+}
+/**
+* The selected cache driver. Only the DEFAULT matters: `cache.drivers` is a
+* menu the scaffold fills in for every driver the framework ships, and warning
+* about a menu entry nobody selected is the false positive this whole check was
+* rewritten to remove.
+*/
+function cachePeer() {
+	const selected = text(config.get("cache.default"));
+	if (!selected || !/redis/i.test(selected)) return void 0;
+	return {
+		package: "redis",
+		because: `cache.default = "${selected}"`
+	};
+}
+/**
+* The selected storage driver, read through its canonical `driver` field
+* (`local` / `s3` / `r2` / `spaces`) rather than the key the app happened to
+* name it, so a driver called "cdn" is still recognised as S3.
+*/
+function storagePeer() {
+	const selected = text(config.get("storage.default"));
+	if (!selected) return void 0;
+	const driver = text(config.get(`storage.drivers.${selected}.driver`));
+	if (!driver || driver === "local") return void 0;
+	return {
+		package: "@aws-sdk/client-s3",
+		because: `storage.default = "${selected}" (driver "${driver}")`
+	};
+}
+/**
+* The mail transport. A `mail` config with no host and no driver is the
+* scaffold's placeholder — every field is an unset env var — so it asks for
+* nothing and this stays quiet.
+*/
+function mailPeer() {
+	if (text(config.get("mail.driver")) === "ses") return {
+		package: "@aws-sdk/client-sesv2",
+		because: `mail.driver = "ses"`
+	};
+	const host = text(config.get("mail.host"));
+	if (!host) return void 0;
+	return {
+		package: "nodemailer",
+		because: `mail.host = "${host}"`
+	};
+}
+/**
+* Realtime sockets. The connector no-ops without a `socket` config, so the
+* presence of that config is exactly the request for the peer.
+*/
+function socketPeer() {
+	if (!config.get("socket")) return void 0;
+	return {
+		package: "socket.io",
+		because: "a socket config is present"
+	};
+}
+/**
+* Every peer THIS project's configuration asks for.
+*/
+function requiredPeers() {
+	return [
+		databasePeer(),
+		cachePeer(),
+		storagePeer(),
+		mailPeer(),
+		socketPeer()
+	].filter((peer) => Boolean(peer));
+}
+/**
+* Checks that every optional peer the project's own configuration selects is
+* actually installed.
+*
+* NEEDS NO BOOTED APP — it reads config and resolves module paths. It runs after
+* the boot pass only because config is loaded by then.
+*
+* WHAT THIS REPLACED, AND WHY: the previous version probed nine packages and
+* warned about every one that was absent. Every one of them is an OPTIONAL
+* peer — a fresh app installs none of them by design — so the check warned, at
+* length, about the framework's own default state. "No MySQL driver installed"
+* is not a diagnosis for someone who never wanted MySQL; it is noise that
+* teaches the reader to skim past the line where a real finding will one day
+* appear.
 *
-* Read-only: resolves module paths only; never imports or executes the peers.
+* Inverted, it becomes a genuine one: a project whose config selects a driver
+* whose package is missing is broken — it will throw the first time that
+* feature is used — so a missing peer here is a `fail`, not a warning.
 */
 const optionalPeersCheck = {
 	name: "optional-peers",
 	run: () => {
-		const missing = OPTIONAL_PEERS.filter((peer) => !isInstalled(peer.package));
-		if (missing.length === 0) return {
+		const required = requiredPeers();
+		if (required.length === 0) return;
+		const missing = required.filter((peer) => !isInstalled(peer.package));
+		const status = missing.length > 0 ? "fail" : "ok";
+		if (missing.length > 0) return {
 			name: "optional-peers",
-			status: "ok",
-			detail: `all ${OPTIONAL_PEERS.length} known optional peers installed`
+			status,
+			detail: `${missing.length} configured feature(s) have no driver installed:\n` + missing.map((peer) => `  - ${peer.package} — required by ${peer.because}`).join("\n")
 		};
 		return {
 			name: "optional-peers",
-			status: "warn",
-			detail: `not installed → unavailable: ${missing.map((peer) => `${peer.package} (${peer.feature})`).join("; ")}`
+			status,
+			detail: `every configured driver is installed (${required.map((peer) => peer.package).join(", ")})`
 		};
 	}
 };

package/esm/cli/commands/doctor/checks/optional-peers.check.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"optional-peers.check.mjs","names":[],"sources":["../../../../../../../../../../core/src/cli/commands/doctor/checks/optional-peers.check.ts"],"sourcesContent":["import { createRequire } from \"node:module\";\nimport type { DoctorCheck } from \"../check.types\";\n\n/**\n * A single optional peer dependency and the feature it unlocks. These are NOT\n * bundled by core — each is loaded lazily by the connector/driver that needs\n * it, so a missing peer simply means that feature is unavailable (a `warn`),\n * never a failure.\n */\ntype OptionalPeer = {\n  /** The npm package name to probe via `require.resolve`. */\n  package: string;\n\n  /** The framework feature this peer enables. */\n  feature: string;\n};\n\n/**\n * The optional peers core knows how to use. Kept in sync with the install\n * targets in the `warlock add` feature registry (sharp, nodemailer, socket.io,\n * the AWS SDK family, redis, the Cascade DB drivers, …).\n */\nconst OPTIONAL_PEERS: OptionalPeer[] = [\n  { package: \"sharp\", feature: \"image processing\" },\n  { package: \"nodemailer\", feature: \"mail (SMTP) channel\" },\n  { package: \"socket.io\", feature: \"realtime socket server\" },\n  { package: \"@aws-sdk/client-s3\", feature: \"S3 cloud storage\" },\n  { package: \"@aws-sdk/client-sesv2\", feature: \"Amazon SES mail channel\" },\n  { package: \"redis\", feature: \"Redis cache driver\" },\n  { package: \"mongodb\", feature: \"MongoDB database driver\" },\n  { package: \"pg\", feature: \"Postgres database driver\" },\n  { package: \"mysql2\", feature: \"MySQL database driver\" },\n];\n\n/**\n * Resolve from the project's working directory, not from core's own\n * `node_modules`, so the probe reflects what the *consuming app* has installed.\n */\nconst projectRequire = createRequire(`${process.cwd()}/package.json`);\n\n/**\n * Whether a package can be resolved from the project. A failed resolve (the\n * normal \"not installed\" case) is swallowed and reported as missing.\n */\nfunction isInstalled(packageName: string): boolean {\n  try {\n    projectRequire.resolve(packageName);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Detects which optional peer dependencies are installed and which are not,\n * reporting the features that are consequently unavailable. Missing peers are\n * a `warn` (the feature is simply off), never a `fail`.\n *\n * Read-only: resolves module paths only; never imports or executes the peers.\n */\nexport const optionalPeersCheck: DoctorCheck = {\n  name: \"optional-peers\",\n  run: () => {\n    const missing = OPTIONAL_PEERS.filter((peer) => !isInstalled(peer.package));\n\n    if (missing.length === 0) {\n      return {\n        name: \"optional-peers\",\n        status: \"ok\",\n        detail: `all ${OPTIONAL_PEERS.length} known optional peers installed`,\n      };\n    }\n\n    const unavailable = missing\n      .map((peer) => `${peer.package} (${peer.feature})`)\n      .join(\"; \");\n\n    return {\n      name: \"optional-peers\",\n      status: \"warn\",\n      detail: `not installed → unavailable: ${unavailable}`,\n    };\n  },\n};\n"],"mappings":";;;;;;;;AAsBA,MAAM,iBAAiC;CACrC;EAAE,SAAS;EAAS,SAAS;CAAmB;CAChD;EAAE,SAAS;EAAc,SAAS;CAAsB;CACxD;EAAE,SAAS;EAAa,SAAS;CAAyB;CAC1D;EAAE,SAAS;EAAsB,SAAS;CAAmB;CAC7D;EAAE,SAAS;EAAyB,SAAS;CAA0B;CACvE;EAAE,SAAS;EAAS,SAAS;CAAqB;CAClD;EAAE,SAAS;EAAW,SAAS;CAA0B;CACzD;EAAE,SAAS;EAAM,SAAS;CAA2B;CACrD;EAAE,SAAS;EAAU,SAAS;CAAwB;AACxD;;;;;AAMA,MAAM,iBAAiB,cAAc,GAAG,QAAQ,IAAI,EAAE,cAAc;;;;;AAMpE,SAAS,YAAY,aAA8B;CACjD,IAAI;EACF,eAAe,QAAQ,WAAW;EAClC,OAAO;CACT,QAAQ;EACN,OAAO;CACT;AACF;;;;;;;;AASA,MAAa,qBAAkC;CAC7C,MAAM;CACN,WAAW;EACT,MAAM,UAAU,eAAe,QAAQ,SAAS,CAAC,YAAY,KAAK,OAAO,CAAC;EAE1E,IAAI,QAAQ,WAAW,GACrB,OAAO;GACL,MAAM;GACN,QAAQ;GACR,QAAQ,OAAO,eAAe,OAAO;EACvC;EAOF,OAAO;GACL,MAAM;GACN,QAAQ;GACR,QAAQ,gCAPU,QACjB,KAAK,SAAS,GAAG,KAAK,QAAQ,IAAI,KAAK,QAAQ,EAAE,CAAC,CAClD,KAAK,IAK4C;EACpD;CACF;AACF"}
+{"version":3,"file":"optional-peers.check.mjs","names":[],"sources":["C:/Work/Warlock.js/core/src/cli/commands/doctor/checks/optional-peers.check.ts"],"sourcesContent":["import { createRequire } from \"node:module\";\nimport { config } from \"../../../../config/config-getter\";\nimport type { CheckStatus, DoctorCheck } from \"../check.types\";\n\n/**\n * A package this project's own configuration requires, and what asked for it.\n */\ntype RequiredPeer = {\n  /** The npm package name to probe via `require.resolve`. */\n  package: string;\n\n  /** The config that asked for it, quoted back to the user verbatim. */\n  because: string;\n};\n\n/**\n * Resolve from the project's working directory, not from core's own\n * `node_modules`, so the probe reflects what the *consuming app* has installed.\n */\nconst projectRequire = createRequire(`${process.cwd()}/package.json`);\n\n/**\n * Whether a package can be resolved from the project. A failed resolve (the\n * normal \"not installed\" case) is swallowed and reported as missing.\n */\nfunction isInstalled(packageName: string): boolean {\n  try {\n    projectRequire.resolve(packageName);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * A non-empty string, or `undefined`. Config values arrive from `env(...)` and\n * an unset variable yields `undefined` — but a `.env` line with nothing after\n * the `=` yields `\"\"`, which is \"not configured\" just as much.\n */\nfunction text(value: unknown): string | undefined {\n  return typeof value === \"string\" && value.trim().length > 0 ? value.trim() : undefined;\n}\n\n/**\n * The database driver's package. `driver` is a closed union in cascade\n * (`mongodb | postgres | mysql`), so an unrecognised value means the config is\n * wrong in a way this check is not the right one to report.\n */\nfunction databasePeer(): RequiredPeer | undefined {\n  const driver = text(config.get(\"database.driver\"));\n\n  const packageName =\n    driver === \"mongodb\"\n      ? \"mongodb\"\n      : driver === \"postgres\"\n        ? \"pg\"\n        : driver === \"mysql\"\n          ? \"mysql2\"\n          : undefined;\n\n  return packageName ? { package: packageName, because: `database.driver = \"${driver}\"` } : undefined;\n}\n\n/**\n * The selected cache driver. Only the DEFAULT matters: `cache.drivers` is a\n * menu the scaffold fills in for every driver the framework ships, and warning\n * about a menu entry nobody selected is the false positive this whole check was\n * rewritten to remove.\n */\nfunction cachePeer(): RequiredPeer | undefined {\n  const selected = text(config.get(\"cache.default\"));\n\n  if (!selected || !/redis/i.test(selected)) return undefined;\n\n  return { package: \"redis\", because: `cache.default = \"${selected}\"` };\n}\n\n/**\n * The selected storage driver, read through its canonical `driver` field\n * (`local` / `s3` / `r2` / `spaces`) rather than the key the app happened to\n * name it, so a driver called \"cdn\" is still recognised as S3.\n */\nfunction storagePeer(): RequiredPeer | undefined {\n  const selected = text(config.get(\"storage.default\"));\n\n  if (!selected) return undefined;\n\n  const driver = text(config.get(`storage.drivers.${selected}.driver`));\n\n  if (!driver || driver === \"local\") return undefined;\n\n  return {\n    package: \"@aws-sdk/client-s3\",\n    because: `storage.default = \"${selected}\" (driver \"${driver}\")`,\n  };\n}\n\n/**\n * The mail transport. A `mail` config with no host and no driver is the\n * scaffold's placeholder — every field is an unset env var — so it asks for\n * nothing and this stays quiet.\n */\nfunction mailPeer(): RequiredPeer | undefined {\n  const driver = text(config.get(\"mail.driver\"));\n\n  if (driver === \"ses\") {\n    return { package: \"@aws-sdk/client-sesv2\", because: `mail.driver = \"ses\"` };\n  }\n\n  const host = text(config.get(\"mail.host\"));\n\n  if (!host) return undefined;\n\n  return { package: \"nodemailer\", because: `mail.host = \"${host}\"` };\n}\n\n/**\n * Realtime sockets. The connector no-ops without a `socket` config, so the\n * presence of that config is exactly the request for the peer.\n */\nfunction socketPeer(): RequiredPeer | undefined {\n  if (!config.get(\"socket\")) return undefined;\n\n  return { package: \"socket.io\", because: \"a socket config is present\" };\n}\n\n/**\n * Every peer THIS project's configuration asks for.\n */\nfunction requiredPeers(): RequiredPeer[] {\n  return [databasePeer(), cachePeer(), storagePeer(), mailPeer(), socketPeer()].filter(\n    (peer): peer is RequiredPeer => Boolean(peer),\n  );\n}\n\n/**\n * Checks that every optional peer the project's own configuration selects is\n * actually installed.\n *\n * NEEDS NO BOOTED APP — it reads config and resolves module paths. It runs after\n * the boot pass only because config is loaded by then.\n *\n * WHAT THIS REPLACED, AND WHY: the previous version probed nine packages and\n * warned about every one that was absent. Every one of them is an OPTIONAL\n * peer — a fresh app installs none of them by design — so the check warned, at\n * length, about the framework's own default state. \"No MySQL driver installed\"\n * is not a diagnosis for someone who never wanted MySQL; it is noise that\n * teaches the reader to skim past the line where a real finding will one day\n * appear.\n *\n * Inverted, it becomes a genuine one: a project whose config selects a driver\n * whose package is missing is broken — it will throw the first time that\n * feature is used — so a missing peer here is a `fail`, not a warning.\n */\nexport const optionalPeersCheck: DoctorCheck = {\n  name: \"optional-peers\",\n  run: () => {\n    const required = requiredPeers();\n\n    if (required.length === 0) {\n      return undefined;\n    }\n\n    const missing = required.filter((peer) => !isInstalled(peer.package));\n\n    const status: CheckStatus = missing.length > 0 ? \"fail\" : \"ok\";\n\n    if (missing.length > 0) {\n      return {\n        name: \"optional-peers\",\n        status,\n        detail:\n          `${missing.length} configured feature(s) have no driver installed:\\n` +\n          missing.map((peer) => `  - ${peer.package} — required by ${peer.because}`).join(\"\\n\"),\n      };\n    }\n\n    return {\n      name: \"optional-peers\",\n      status,\n      detail: `every configured driver is installed (${required\n        .map((peer) => peer.package)\n        .join(\", \")})`,\n    };\n  },\n};\n"],"mappings":";;;;;;;;AAmBA,MAAM,iBAAiB,cAAc,GAAG,QAAQ,IAAI,EAAE,cAAc;;;;;AAMpE,SAAS,YAAY,aAA8B;CACjD,IAAI;EACF,eAAe,QAAQ,WAAW;EAClC,OAAO;CACT,QAAQ;EACN,OAAO;CACT;AACF;;;;;;AAOA,SAAS,KAAK,OAAoC;CAChD,OAAO,OAAO,UAAU,YAAY,MAAM,KAAK,EAAE,SAAS,IAAI,MAAM,KAAK,IAAI;AAC/E;;;;;;AAOA,SAAS,eAAyC;CAChD,MAAM,SAAS,KAAK,OAAO,IAAI,iBAAiB,CAAC;CAEjD,MAAM,cACJ,WAAW,YACP,YACA,WAAW,aACT,OACA,WAAW,UACT,WACA;CAEV,OAAO,cAAc;EAAE,SAAS;EAAa,SAAS,sBAAsB,OAAO;CAAG,IAAI;AAC5F;;;;;;;AAQA,SAAS,YAAsC;CAC7C,MAAM,WAAW,KAAK,OAAO,IAAI,eAAe,CAAC;CAEjD,IAAI,CAAC,YAAY,CAAC,SAAS,KAAK,QAAQ,GAAG,OAAO;CAElD,OAAO;EAAE,SAAS;EAAS,SAAS,oBAAoB,SAAS;CAAG;AACtE;;;;;;AAOA,SAAS,cAAwC;CAC/C,MAAM,WAAW,KAAK,OAAO,IAAI,iBAAiB,CAAC;CAEnD,IAAI,CAAC,UAAU,OAAO;CAEtB,MAAM,SAAS,KAAK,OAAO,IAAI,mBAAmB,SAAS,QAAQ,CAAC;CAEpE,IAAI,CAAC,UAAU,WAAW,SAAS,OAAO;CAE1C,OAAO;EACL,SAAS;EACT,SAAS,sBAAsB,SAAS,aAAa,OAAO;CAC9D;AACF;;;;;;AAOA,SAAS,WAAqC;CAG5C,IAFe,KAAK,OAAO,IAAI,aAAa,CAEnC,MAAM,OACb,OAAO;EAAE,SAAS;EAAyB,SAAS;CAAsB;CAG5E,MAAM,OAAO,KAAK,OAAO,IAAI,WAAW,CAAC;CAEzC,IAAI,CAAC,MAAM,OAAO;CAElB,OAAO;EAAE,SAAS;EAAc,SAAS,gBAAgB,KAAK;CAAG;AACnE;;;;;AAMA,SAAS,aAAuC;CAC9C,IAAI,CAAC,OAAO,IAAI,QAAQ,GAAG,OAAO;CAElC,OAAO;EAAE,SAAS;EAAa,SAAS;CAA6B;AACvE;;;;AAKA,SAAS,gBAAgC;CACvC,OAAO;EAAC,aAAa;EAAG,UAAU;EAAG,YAAY;EAAG,SAAS;EAAG,WAAW;CAAC,EAAE,QAC3E,SAA+B,QAAQ,IAAI,CAC9C;AACF;;;;;;;;;;;;;;;;;;;;AAqBA,MAAa,qBAAkC;CAC7C,MAAM;CACN,WAAW;EACT,MAAM,WAAW,cAAc;EAE/B,IAAI,SAAS,WAAW,GACtB;EAGF,MAAM,UAAU,SAAS,QAAQ,SAAS,CAAC,YAAY,KAAK,OAAO,CAAC;EAEpE,MAAM,SAAsB,QAAQ,SAAS,IAAI,SAAS;EAE1D,IAAI,QAAQ,SAAS,GACnB,OAAO;GACL,MAAM;GACN;GACA,QACE,GAAG,QAAQ,OAAO,sDAClB,QAAQ,KAAK,SAAS,OAAO,KAAK,QAAQ,iBAAiB,KAAK,SAAS,EAAE,KAAK,IAAI;EACxF;EAGF,OAAO;GACL,MAAM;GACN;GACA,QAAQ,yCAAyC,SAC9C,KAAK,SAAS,KAAK,OAAO,EAC1B,KAAK,IAAI,EAAE;EAChB;CACF;AACF"}

package/esm/cli/commands/doctor/checks/release-hygiene.check.mjs

@@ -1,7 +1,7 @@
 import { rootPath } from "../../../../utils/paths.mjs";
 import { existsSync, readFileSync } from "node:fs";
 
-//#region ../core/src/cli/commands/doctor/checks/release-hygiene.check.ts
+//#region core/src/cli/commands/doctor/checks/release-hygiene.check.ts
 /**
 * Parse the top-most `## x.y.z[ - YYYY-MM-DD]` heading out of a CHANGELOG body.
 * Returns `undefined` when no version heading is present.
@@ -16,29 +16,47 @@ function parseTopHeading(changelog) {
 	};
 }
 /**
-* Checks that the project's `package.json` version matches the top-most
-* `## x.y.z` heading in `CHANGELOG.md` — the same version↔changelog invariant
-* the release-hygiene unit guard enforces, surfaced as a pre-release doctor
-* check.
+* Whether this project is something anyone could `npm publish`.
+*
+* THE GATE, and the reason it exists: a changelog is a promise to the people
+* who install your package. An application has no such people. Running this
+* check on every project projected the framework monorepo's own release
+* practice onto users building an app, who were told — on every single run,
+* forever — that their private application was missing a CHANGELOG.md it had no
+* reason to have. `"private": true` is exactly the field npm itself reads to
+* refuse a publish, so it is the honest test of whether the concern applies.
+*/
+function isPublishable(manifest) {
+	return manifest.private !== true && typeof manifest.name === "string";
+}
+/**
+* Checks that a PUBLISHABLE package's `package.json` version matches the
+* top-most `## x.y.z` heading in `CHANGELOG.md` — the same version↔changelog
+* invariant the release-hygiene unit guard enforces, surfaced as a pre-release
+* doctor check.
+*
+* NEEDS NO BOOTED APP — it reads two files from the project root.
 *
 * Verdicts:
-* - no `CHANGELOG.md` → `warn` (a changelog is recommended, not mandatory);
+* - `"private": true`, or no package name → not applicable, no line at all;
+* - no `CHANGELOG.md` → `warn` (recommended for a published package, not
+*   mandatory);
 * - no parseable heading → `warn`;
 * - heading version ≠ package.json version → `fail`;
 * - otherwise → `ok`.
-*
-* Read-only: reads `package.json` and `CHANGELOG.md` from the project root.
 */
 const releaseHygieneCheck = {
 	name: "release-hygiene",
 	run: () => {
 		const packageJsonPath = rootPath("package.json");
 		const changelogPath = rootPath("CHANGELOG.md");
-		const pkgVersion = JSON.parse(readFileSync(packageJsonPath, "utf8")).version;
+		const manifest = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+		if (!isPublishable(manifest)) return;
+		const pkgVersion = manifest.version;
 		if (typeof pkgVersion !== "string") return {
 			name: "release-hygiene",
 			status: "fail",
-			detail: "package.json has no string version field"
+			detail: "package.json is publishable but has no string version field"
 		};
 		if (!existsSync(changelogPath)) return {
 			name: "release-hygiene",

package/esm/cli/commands/doctor/checks/release-hygiene.check.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"release-hygiene.check.mjs","names":[],"sources":["../../../../../../../../../../core/src/cli/commands/doctor/checks/release-hygiene.check.ts"],"sourcesContent":["import { existsSync, readFileSync } from \"node:fs\";\nimport { rootPath } from \"../../../../utils/paths\";\nimport type { DoctorCheck } from \"../check.types\";\n\n/**\n * A `## x.y.z` changelog heading with an optional ` - YYYY-MM-DD` suffix.\n * Mirrors the shape parsed by the tier-0 release-hygiene unit guard; inlined\n * here because that guard lives in the test tree and is not importable from\n * `src`.\n */\ntype ChangelogHeading = {\n  version: string;\n  date?: string;\n};\n\n/**\n * Parse the top-most `## x.y.z[ - YYYY-MM-DD]` heading out of a CHANGELOG body.\n * Returns `undefined` when no version heading is present.\n */\nfunction parseTopHeading(changelog: string): ChangelogHeading | undefined {\n  const match = changelog.match(\n    /^##\\s+(\\d+)\\.(\\d+)\\.(\\d+)(?:\\s*[-–]\\s*(\\d{4}-\\d{2}-\\d{2}))?\\s*$/m,\n  );\n\n  if (!match) {\n    return undefined;\n  }\n\n  const [, major, minor, patch, date] = match;\n\n  return {\n    version: `${major}.${minor}.${patch}`,\n    date,\n  };\n}\n\n/**\n * Checks that the project's `package.json` version matches the top-most\n * `## x.y.z` heading in `CHANGELOG.md` — the same version↔changelog invariant\n * the release-hygiene unit guard enforces, surfaced as a pre-release doctor\n * check.\n *\n * Verdicts:\n * - no `CHANGELOG.md` → `warn` (a changelog is recommended, not mandatory);\n * - no parseable heading → `warn`;\n * - heading version ≠ package.json version → `fail`;\n * - otherwise → `ok`.\n *\n * Read-only: reads `package.json` and `CHANGELOG.md` from the project root.\n */\nexport const releaseHygieneCheck: DoctorCheck = {\n  name: \"release-hygiene\",\n  run: () => {\n    const packageJsonPath = rootPath(\"package.json\");\n    const changelogPath = rootPath(\"CHANGELOG.md\");\n\n    const pkgVersion: unknown = JSON.parse(readFileSync(packageJsonPath, \"utf8\")).version;\n\n    if (typeof pkgVersion !== \"string\") {\n      return {\n        name: \"release-hygiene\",\n        status: \"fail\",\n        detail: \"package.json has no string version field\",\n      };\n    }\n\n    if (!existsSync(changelogPath)) {\n      return {\n        name: \"release-hygiene\",\n        status: \"warn\",\n        detail: `no CHANGELOG.md at project root (package.json is ${pkgVersion})`,\n      };\n    }\n\n    const changelog = readFileSync(changelogPath, \"utf8\");\n    const heading = parseTopHeading(changelog);\n\n    if (!heading) {\n      return {\n        name: \"release-hygiene\",\n        status: \"warn\",\n        detail: \"CHANGELOG.md has no parseable `## x.y.z` heading\",\n      };\n    }\n\n    if (heading.version !== pkgVersion) {\n      return {\n        name: \"release-hygiene\",\n        status: \"fail\",\n        detail: `package.json ${pkgVersion} ≠ top CHANGELOG heading ${heading.version}`,\n      };\n    }\n\n    return {\n      name: \"release-hygiene\",\n      status: \"ok\",\n      detail: `package.json and CHANGELOG agree on ${pkgVersion}`,\n    };\n  },\n};\n"],"mappings":";;;;;;;;AAmBA,SAAS,gBAAgB,WAAiD;CACxE,MAAM,QAAQ,UAAU,MACtB,kEACF;CAEA,IAAI,CAAC,OACH;CAGF,MAAM,GAAG,OAAO,OAAO,OAAO,QAAQ;CAEtC,OAAO;EACL,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG;EAC9B;CACF;AACF;;;;;;;;;;;;;;;AAgBA,MAAa,sBAAmC;CAC9C,MAAM;CACN,WAAW;EACT,MAAM,kBAAkB,SAAS,cAAc;EAC/C,MAAM,gBAAgB,SAAS,cAAc;EAE7C,MAAM,aAAsB,KAAK,MAAM,aAAa,iBAAiB,MAAM,CAAC,CAAC,CAAC;EAE9E,IAAI,OAAO,eAAe,UACxB,OAAO;GACL,MAAM;GACN,QAAQ;GACR,QAAQ;EACV;EAGF,IAAI,CAAC,WAAW,aAAa,GAC3B,OAAO;GACL,MAAM;GACN,QAAQ;GACR,QAAQ,oDAAoD,WAAW;EACzE;EAIF,MAAM,UAAU,gBADE,aAAa,eAAe,MACN,CAAC;EAEzC,IAAI,CAAC,SACH,OAAO;GACL,MAAM;GACN,QAAQ;GACR,QAAQ;EACV;EAGF,IAAI,QAAQ,YAAY,YACtB,OAAO;GACL,MAAM;GACN,QAAQ;GACR,QAAQ,gBAAgB,WAAW,2BAA2B,QAAQ;EACxE;EAGF,OAAO;GACL,MAAM;GACN,QAAQ;GACR,QAAQ,uCAAuC;EACjD;CACF;AACF"}
+{"version":3,"file":"release-hygiene.check.mjs","names":[],"sources":["C:/Work/Warlock.js/core/src/cli/commands/doctor/checks/release-hygiene.check.ts"],"sourcesContent":["import { existsSync, readFileSync } from \"node:fs\";\nimport { rootPath } from \"../../../../utils/paths\";\nimport type { DoctorCheck } from \"../check.types\";\n\n/**\n * A `## x.y.z` changelog heading with an optional ` - YYYY-MM-DD` suffix.\n * Mirrors the shape parsed by the tier-0 release-hygiene unit guard; inlined\n * here because that guard lives in the test tree and is not importable from\n * `src`.\n */\ntype ChangelogHeading = {\n  version: string;\n  date?: string;\n};\n\n/**\n * The parts of `package.json` this check reads.\n */\ntype ProjectManifest = {\n  version?: unknown;\n  private?: unknown;\n  name?: unknown;\n};\n\n/**\n * Parse the top-most `## x.y.z[ - YYYY-MM-DD]` heading out of a CHANGELOG body.\n * Returns `undefined` when no version heading is present.\n */\nfunction parseTopHeading(changelog: string): ChangelogHeading | undefined {\n  const match = changelog.match(\n    /^##\\s+(\\d+)\\.(\\d+)\\.(\\d+)(?:\\s*[-–]\\s*(\\d{4}-\\d{2}-\\d{2}))?\\s*$/m,\n  );\n\n  if (!match) {\n    return undefined;\n  }\n\n  const [, major, minor, patch, date] = match;\n\n  return {\n    version: `${major}.${minor}.${patch}`,\n    date,\n  };\n}\n\n/**\n * Whether this project is something anyone could `npm publish`.\n *\n * THE GATE, and the reason it exists: a changelog is a promise to the people\n * who install your package. An application has no such people. Running this\n * check on every project projected the framework monorepo's own release\n * practice onto users building an app, who were told — on every single run,\n * forever — that their private application was missing a CHANGELOG.md it had no\n * reason to have. `\"private\": true` is exactly the field npm itself reads to\n * refuse a publish, so it is the honest test of whether the concern applies.\n */\nfunction isPublishable(manifest: ProjectManifest): boolean {\n  return manifest.private !== true && typeof manifest.name === \"string\";\n}\n\n/**\n * Checks that a PUBLISHABLE package's `package.json` version matches the\n * top-most `## x.y.z` heading in `CHANGELOG.md` — the same version↔changelog\n * invariant the release-hygiene unit guard enforces, surfaced as a pre-release\n * doctor check.\n *\n * NEEDS NO BOOTED APP — it reads two files from the project root.\n *\n * Verdicts:\n * - `\"private\": true`, or no package name → not applicable, no line at all;\n * - no `CHANGELOG.md` → `warn` (recommended for a published package, not\n *   mandatory);\n * - no parseable heading → `warn`;\n * - heading version ≠ package.json version → `fail`;\n * - otherwise → `ok`.\n */\nexport const releaseHygieneCheck: DoctorCheck = {\n  name: \"release-hygiene\",\n  run: () => {\n    const packageJsonPath = rootPath(\"package.json\");\n    const changelogPath = rootPath(\"CHANGELOG.md\");\n\n    const manifest: ProjectManifest = JSON.parse(readFileSync(packageJsonPath, \"utf8\"));\n\n    if (!isPublishable(manifest)) {\n      return undefined;\n    }\n\n    const pkgVersion = manifest.version;\n\n    if (typeof pkgVersion !== \"string\") {\n      return {\n        name: \"release-hygiene\",\n        status: \"fail\",\n        detail: \"package.json is publishable but has no string version field\",\n      };\n    }\n\n    if (!existsSync(changelogPath)) {\n      return {\n        name: \"release-hygiene\",\n        status: \"warn\",\n        detail: `no CHANGELOG.md at project root (package.json is ${pkgVersion})`,\n      };\n    }\n\n    const changelog = readFileSync(changelogPath, \"utf8\");\n    const heading = parseTopHeading(changelog);\n\n    if (!heading) {\n      return {\n        name: \"release-hygiene\",\n        status: \"warn\",\n        detail: \"CHANGELOG.md has no parseable `## x.y.z` heading\",\n      };\n    }\n\n    if (heading.version !== pkgVersion) {\n      return {\n        name: \"release-hygiene\",\n        status: \"fail\",\n        detail: `package.json ${pkgVersion} ≠ top CHANGELOG heading ${heading.version}`,\n      };\n    }\n\n    return {\n      name: \"release-hygiene\",\n      status: \"ok\",\n      detail: `package.json and CHANGELOG agree on ${pkgVersion}`,\n    };\n  },\n};\n"],"mappings":";;;;;;;;AA4BA,SAAS,gBAAgB,WAAiD;CACxE,MAAM,QAAQ,UAAU,MACtB,kEACF;CAEA,IAAI,CAAC,OACH;CAGF,MAAM,GAAG,OAAO,OAAO,OAAO,QAAQ;CAEtC,OAAO;EACL,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG;EAC9B;CACF;AACF;;;;;;;;;;;;AAaA,SAAS,cAAc,UAAoC;CACzD,OAAO,SAAS,YAAY,QAAQ,OAAO,SAAS,SAAS;AAC/D;;;;;;;;;;;;;;;;;AAkBA,MAAa,sBAAmC;CAC9C,MAAM;CACN,WAAW;EACT,MAAM,kBAAkB,SAAS,cAAc;EAC/C,MAAM,gBAAgB,SAAS,cAAc;EAE7C,MAAM,WAA4B,KAAK,MAAM,aAAa,iBAAiB,MAAM,CAAC;EAElF,IAAI,CAAC,cAAc,QAAQ,GACzB;EAGF,MAAM,aAAa,SAAS;EAE5B,IAAI,OAAO,eAAe,UACxB,OAAO;GACL,MAAM;GACN,QAAQ;GACR,QAAQ;EACV;EAGF,IAAI,CAAC,WAAW,aAAa,GAC3B,OAAO;GACL,MAAM;GACN,QAAQ;GACR,QAAQ,oDAAoD,WAAW;EACzE;EAIF,MAAM,UAAU,gBADE,aAAa,eAAe,MACN,CAAC;EAEzC,IAAI,CAAC,SACH,OAAO;GACL,MAAM;GACN,QAAQ;GACR,QAAQ;EACV;EAGF,IAAI,QAAQ,YAAY,YACtB,OAAO;GACL,MAAM;GACN,QAAQ;GACR,QAAQ,gBAAgB,WAAW,2BAA2B,QAAQ;EACxE;EAGF,OAAO;GACL,MAAM;GACN,QAAQ;GACR,QAAQ,uCAAuC;EACjD;CACF;AACF"}

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

@@ -1,26 +1,65 @@
-import { router } from "../../../../router/router.mjs";
-
-//#region ../core/src/cli/commands/doctor/checks/routes.check.ts
+//#region core/src/cli/commands/doctor/checks/routes.check.ts
+/**
+* Describe the failed modules as an indented block, one per line, cause first.
+* The file that failed is the only thing that makes this actionable, so it is
+* never summarised away.
+*/
+function describeFailures(context) {
+	return context.moduleFailures.map((failure) => `  - ${failure.file}: ${failure.message}`).join("\n");
+}
 /**
-* Reports the number of registered routes. A booted app with zero routes
-* almost always means a route module failed to register silently, so this
-* warns (rather than passing) when the route table is empty.
+* Reports the route surface the app will actually serve.
 *
-* Read-only: introspects the router via `routeCount()` only.
+* NEEDS A BOOTED APP — and now gets one. Routes exist only as the side effect of
+* importing the module that declares them, so a doctor that did not import app
+* code reported `0 routes` for an app the dev server served fourteen routes
+* for. The boot pass imports the same modules, in the same order, and boots
+* (never starts) the same connectors, so the number printed here is the number
+* `warlock dev` prints for the same project — the two are read off the same
+* router after the same registrations.
+*
+* Verdicts:
+* - a module failed to import → `fail`, naming every file and its cause. This
+*   is the finding doctor exists for: a route file that throws on import is
+*   invisible at runtime, it just 404s;
+* - route modules on disk but nothing registered → `fail` (they loaded and
+*   registered nothing, which is not a state a working app is in);
+* - no route modules at all → `ok`, stated plainly. A worker or CLI-only app is
+*   a legitimate shape and must not be nagged;
+* - otherwise → `ok` with the count, split into what app code registered and
+*   what connectors added.
 */
 const routesCheck = {
 	name: "routes",
-	run: () => {
-		const count = router.routeCount();
-		if (count === 0) return {
+	run: (context) => {
+		if (context.moduleFailures.length > 0) return {
+			name: "routes",
+			status: "fail",
+			detail: `${context.moduleFailures.length} app module(s) failed to load — the routes they declare will 404:\n` + describeFailures(context)
+		};
+		if (!context.booted) return {
 			name: "routes",
-			status: "warn",
-			detail: "0 routes registered — did a route module fail to load?"
+			status: "fail",
+			detail: "app modules could not be discovered — nothing to report on"
 		};
+		if (context.totalRoutes === 0) {
+			if (context.routeModules === 0) return {
+				name: "routes",
+				status: "ok",
+				detail: "no route modules found (src/app/*/routes.ts) — this app serves no HTTP routes"
+			};
+			return {
+				name: "routes",
+				status: "fail",
+				detail: `${context.routeModules} route module(s) loaded without error but registered 0 routes — every request will 404`
+			};
+		}
+		const fromConnectors = context.totalRoutes - context.appRoutes;
+		const breakdown = fromConnectors > 0 ? `${context.appRoutes} from ${context.routeModules} route module(s), ${fromConnectors} from connectors` : `from ${context.routeModules} route module(s)`;
 		return {
 			name: "routes",
 			status: "ok",
-			detail: `${count} registered`
+			detail: `${context.totalRoutes} registered (${breakdown})`
 		};
 	}
 };

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

@@ -1 +1 @@
-{"version":3,"file":"routes.check.mjs","names":[],"sources":["../../../../../../../../../../core/src/cli/commands/doctor/checks/routes.check.ts"],"sourcesContent":["import { router } from \"../../../../router/router\";\nimport type { DoctorCheck } from \"../check.types\";\n\n/**\n * Reports the number of registered routes. A booted app with zero routes\n * almost always means a route module failed to register silently, so this\n * warns (rather than passing) when the route table is empty.\n *\n * Read-only: introspects the router via `routeCount()` only.\n */\nexport const routesCheck: DoctorCheck = {\n  name: \"routes\",\n  run: () => {\n    const count = router.routeCount();\n\n    if (count === 0) {\n      return {\n        name: \"routes\",\n        status: \"warn\",\n        detail: \"0 routes registered — did a route module fail to load?\",\n      };\n    }\n\n    return {\n      name: \"routes\",\n      status: \"ok\",\n      detail: `${count} registered`,\n    };\n  },\n};\n"],"mappings":";;;;;;;;;;AAUA,MAAa,cAA2B;CACtC,MAAM;CACN,WAAW;EACT,MAAM,QAAQ,OAAO,WAAW;EAEhC,IAAI,UAAU,GACZ,OAAO;GACL,MAAM;GACN,QAAQ;GACR,QAAQ;EACV;EAGF,OAAO;GACL,MAAM;GACN,QAAQ;GACR,QAAQ,GAAG,MAAM;EACnB;CACF;AACF"}
+{"version":3,"file":"routes.check.mjs","names":[],"sources":["C:/Work/Warlock.js/core/src/cli/commands/doctor/checks/routes.check.ts"],"sourcesContent":["import type { DoctorBootContext, DoctorCheck } from \"../check.types\";\n\n/**\n * Describe the failed modules as an indented block, one per line, cause first.\n * The file that failed is the only thing that makes this actionable, so it is\n * never summarised away.\n */\nfunction describeFailures(context: DoctorBootContext): string {\n  return context.moduleFailures\n    .map((failure) => `  - ${failure.file}: ${failure.message}`)\n    .join(\"\\n\");\n}\n\n/**\n * Reports the route surface the app will actually serve.\n *\n * NEEDS A BOOTED APP — and now gets one. Routes exist only as the side effect of\n * importing the module that declares them, so a doctor that did not import app\n * code reported `0 routes` for an app the dev server served fourteen routes\n * for. The boot pass imports the same modules, in the same order, and boots\n * (never starts) the same connectors, so the number printed here is the number\n * `warlock dev` prints for the same project — the two are read off the same\n * router after the same registrations.\n *\n * Verdicts:\n * - a module failed to import → `fail`, naming every file and its cause. This\n *   is the finding doctor exists for: a route file that throws on import is\n *   invisible at runtime, it just 404s;\n * - route modules on disk but nothing registered → `fail` (they loaded and\n *   registered nothing, which is not a state a working app is in);\n * - no route modules at all → `ok`, stated plainly. A worker or CLI-only app is\n *   a legitimate shape and must not be nagged;\n * - otherwise → `ok` with the count, split into what app code registered and\n *   what connectors added.\n */\nexport const routesCheck: DoctorCheck = {\n  name: \"routes\",\n  run: (context) => {\n    if (context.moduleFailures.length > 0) {\n      const count = context.moduleFailures.length;\n\n      return {\n        name: \"routes\",\n        status: \"fail\",\n        detail:\n          `${count} app module(s) failed to load — the routes they declare will 404:\\n` +\n          describeFailures(context),\n      };\n    }\n\n    if (!context.booted) {\n      return {\n        name: \"routes\",\n        status: \"fail\",\n        detail: \"app modules could not be discovered — nothing to report on\",\n      };\n    }\n\n    if (context.totalRoutes === 0) {\n      if (context.routeModules === 0) {\n        return {\n          name: \"routes\",\n          status: \"ok\",\n          detail: \"no route modules found (src/app/*/routes.ts) — this app serves no HTTP routes\",\n        };\n      }\n\n      return {\n        name: \"routes\",\n        status: \"fail\",\n        detail:\n          `${context.routeModules} route module(s) loaded without error but registered 0 routes — ` +\n          \"every request will 404\",\n      };\n    }\n\n    const fromConnectors = context.totalRoutes - context.appRoutes;\n    const breakdown =\n      fromConnectors > 0\n        ? `${context.appRoutes} from ${context.routeModules} route module(s), ` +\n          `${fromConnectors} from connectors`\n        : `from ${context.routeModules} route module(s)`;\n\n    return {\n      name: \"routes\",\n      status: \"ok\",\n      detail: `${context.totalRoutes} registered (${breakdown})`,\n    };\n  },\n};\n"],"mappings":";;;;;;AAOA,SAAS,iBAAiB,SAAoC;CAC5D,OAAO,QAAQ,eACZ,KAAK,YAAY,OAAO,QAAQ,KAAK,IAAI,QAAQ,SAAS,EAC1D,KAAK,IAAI;AACd;;;;;;;;;;;;;;;;;;;;;;;AAwBA,MAAa,cAA2B;CACtC,MAAM;CACN,MAAM,YAAY;EAChB,IAAI,QAAQ,eAAe,SAAS,GAGlC,OAAO;GACL,MAAM;GACN,QAAQ;GACR,QACE,GANU,QAAQ,eAAe,OAMxB,uEACT,iBAAiB,OAAO;EAC5B;EAGF,IAAI,CAAC,QAAQ,QACX,OAAO;GACL,MAAM;GACN,QAAQ;GACR,QAAQ;EACV;EAGF,IAAI,QAAQ,gBAAgB,GAAG;GAC7B,IAAI,QAAQ,iBAAiB,GAC3B,OAAO;IACL,MAAM;IACN,QAAQ;IACR,QAAQ;GACV;GAGF,OAAO;IACL,MAAM;IACN,QAAQ;IACR,QACE,GAAG,QAAQ,aAAa;GAE5B;EACF;EAEA,MAAM,iBAAiB,QAAQ,cAAc,QAAQ;EACrD,MAAM,YACJ,iBAAiB,IACb,GAAG,QAAQ,UAAU,QAAQ,QAAQ,aAAa,oBAC/C,eAAe,oBAClB,QAAQ,QAAQ,aAAa;EAEnC,OAAO;GACL,MAAM;GACN,QAAQ;GACR,QAAQ,GAAG,QAAQ,YAAY,eAAe,UAAU;EAC1D;CACF;AACF"}

package/esm/cli/commands/doctor/doctor-command.action.mjs

@@ -1,24 +1,34 @@
+import { bootForDiagnostics } from "./boot-for-diagnostics.mjs";
 import { defaultDoctorChecks } from "./checks/index.mjs";
 import { printReport } from "./format-report.mjs";
 import { runChecks } from "./run-checks.mjs";
 
-//#region ../core/src/cli/commands/doctor/doctor-command.action.ts
+//#region core/src/cli/commands/doctor/doctor-command.action.ts
 /**
-* Action behind `warlock doctor`. Runs the default read-only diagnostic
-* checks, prints the grouped pass/warn/fail report, and — when any check
-* failed — exits the process with a non-zero code so the command signals
-* failure to scripts/CI.
+* Action behind `warlock doctor`.
+*
+* Two steps, in this order and for a reason: ONE boot pass, then every check
+* against what that pass observed. The checks never boot anything themselves,
+* so the report cannot contain two lines that inspected the app at different
+* moments and contradicted each other — which is exactly what it used to
+* contain (`routes: 0 registered` beside `health: /health + /ready
+* registered`, in the same run, on an app serving fourteen routes).
+*
+* The pass boots every connector and starts none, so no database, cache or
+* socket connection is opened and no port is bound. See
+* `boot-for-diagnostics.ts`.
 *
 * A failing check is REPORTED (a line in the report + a non-zero exit), never
 * thrown: the runner converts any thrown check into a `fail` result first.
 *
 * On success this simply returns; the CLI manager then prints its own success
-* banner and exits zero.
+* banner and exits zero — which also disposes of the handles the boot pass
+* left open (a Fastify instance, a Vite dev server for `web` apps).
 *
 * @param _data Parsed CLI args (unused — doctor takes no positional args).
 */
 async function doctorCommandAction(_data) {
-	const report = await runChecks(defaultDoctorChecks);
+	const report = await runChecks(defaultDoctorChecks, await bootForDiagnostics());
 	printReport(report);
 	if (report.hasFailures) process.exit(report.exitCode);
 }

package/esm/cli/commands/doctor/doctor-command.action.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"doctor-command.action.mjs","names":[],"sources":["../../../../../../../../../core/src/cli/commands/doctor/doctor-command.action.ts"],"sourcesContent":["import type { CommandActionData } from \"../../../commands/types\";\r\nimport { defaultDoctorChecks } from \"./checks\";\r\nimport { printReport } from \"./format-report\";\r\nimport { runChecks } from \"./run-checks\";\r\n\r\n/**\r\n * Action behind `warlock doctor`. Runs the default read-only diagnostic\r\n * checks, prints the grouped pass/warn/fail report, and — when any check\r\n * failed — exits the process with a non-zero code so the command signals\r\n * failure to scripts/CI.\r\n *\r\n * A failing check is REPORTED (a line in the report + a non-zero exit), never\r\n * thrown: the runner converts any thrown check into a `fail` result first.\r\n *\r\n * On success this simply returns; the CLI manager then prints its own success\r\n * banner and exits zero.\r\n *\r\n * @param _data Parsed CLI args (unused — doctor takes no positional args).\r\n */\r\nexport async function doctorCommandAction(_data: CommandActionData): Promise<void> {\r\n  const report = await runChecks(defaultDoctorChecks);\r\n\r\n  printReport(report);\r\n\r\n  if (report.hasFailures) {\r\n    process.exit(report.exitCode);\r\n  }\r\n}\r\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAmBA,eAAsB,oBAAoB,OAAyC;CACjF,MAAM,SAAS,MAAM,UAAU,mBAAmB;CAElD,YAAY,MAAM;CAElB,IAAI,OAAO,aACT,QAAQ,KAAK,OAAO,QAAQ;AAEhC"}
+{"version":3,"file":"doctor-command.action.mjs","names":[],"sources":["C:/Work/Warlock.js/core/src/cli/commands/doctor/doctor-command.action.ts"],"sourcesContent":["import type { CommandActionData } from \"../../../commands/types\";\nimport { bootForDiagnostics } from \"./boot-for-diagnostics\";\nimport { defaultDoctorChecks } from \"./checks\";\nimport { printReport } from \"./format-report\";\nimport { runChecks } from \"./run-checks\";\n\n/**\n * Action behind `warlock doctor`.\n *\n * Two steps, in this order and for a reason: ONE boot pass, then every check\n * against what that pass observed. The checks never boot anything themselves,\n * so the report cannot contain two lines that inspected the app at different\n * moments and contradicted each other — which is exactly what it used to\n * contain (`routes: 0 registered` beside `health: /health + /ready\n * registered`, in the same run, on an app serving fourteen routes).\n *\n * The pass boots every connector and starts none, so no database, cache or\n * socket connection is opened and no port is bound. See\n * `boot-for-diagnostics.ts`.\n *\n * A failing check is REPORTED (a line in the report + a non-zero exit), never\n * thrown: the runner converts any thrown check into a `fail` result first.\n *\n * On success this simply returns; the CLI manager then prints its own success\n * banner and exits zero — which also disposes of the handles the boot pass\n * left open (a Fastify instance, a Vite dev server for `web` apps).\n *\n * @param _data Parsed CLI args (unused — doctor takes no positional args).\n */\nexport async function doctorCommandAction(_data: CommandActionData): Promise<void> {\n  const context = await bootForDiagnostics();\n\n  const report = await runChecks(defaultDoctorChecks, context);\n\n  printReport(report);\n\n  if (report.hasFailures) {\n    process.exit(report.exitCode);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,eAAsB,oBAAoB,OAAyC;CAGjF,MAAM,SAAS,MAAM,UAAU,qBAAqB,MAF9B,mBAAmB,CAEkB;CAE3D,YAAY,MAAM;CAElB,IAAI,OAAO,aACT,QAAQ,KAAK,OAAO,QAAQ;AAEhC"}

package/esm/cli/commands/doctor/format-report.mjs

@@ -1,6 +1,6 @@
 import { colors } from "@mongez/copper";
 
-//#region ../core/src/cli/commands/doctor/format-report.ts
+//#region core/src/cli/commands/doctor/format-report.ts
 /**
 * The glyph shown beside each check, keyed by status.
 */

package/esm/cli/commands/doctor/format-report.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"format-report.mjs","names":[],"sources":["../../../../../../../../../core/src/cli/commands/doctor/format-report.ts"],"sourcesContent":["import { colors } from \"@mongez/copper\";\nimport type { CheckStatus, DoctorReport } from \"./check.types\";\n\n/**\n * The glyph shown beside each check, keyed by status.\n */\nconst STATUS_SYMBOL: Record<CheckStatus, string> = {\n  ok: \"✓\",\n  warn: \"⚠\",\n  fail: \"✗\",\n};\n\n/**\n * Colorize a status glyph. Kept separate from {@link STATUS_SYMBOL} so the\n * plain glyphs remain available for snapshot-friendly, color-free assertions.\n */\nfunction colorizeSymbol(status: CheckStatus): string {\n  const symbol = STATUS_SYMBOL[status];\n\n  switch (status) {\n    case \"ok\":\n      return colors.green(symbol);\n    case \"warn\":\n      return colors.yellow(symbol);\n    case \"fail\":\n      return colors.red(symbol);\n  }\n}\n\n/**\n * Build the report body as an ordered list of plain (uncolored) lines:\n * one `<symbol> <name>: <detail>` line per check, a blank line, then a summary\n * line. Returned as strings (not printed) so the formatting is unit-testable.\n *\n * @param report The aggregated doctor report.\n * @returns The lines to print, top to bottom.\n */\nexport function formatReportLines(report: DoctorReport): string[] {\n  const lines = report.results.map((result) => {\n    return `${STATUS_SYMBOL[result.status]} ${result.name}: ${result.detail}`;\n  });\n\n  const { ok, warn, fail } = report.summary;\n\n  lines.push(\"\");\n  lines.push(`Summary: ${ok} ok, ${warn} warn, ${fail} fail`);\n\n  return lines;\n}\n\n/**\n * Print the report to stdout with colored status glyphs and a colored summary\n * verdict. Thin wrapper over {@link formatReportLines} — the structured report\n * stays the source of truth for the exit code.\n *\n * @param report The aggregated doctor report.\n */\nexport function printReport(report: DoctorReport): void {\n  for (const result of report.results) {\n    const symbol = colorizeSymbol(result.status);\n\n    console.log(`${symbol} ${colors.bold(result.name)}: ${result.detail}`);\n  }\n\n  const { ok, warn, fail } = report.summary;\n  const summaryLine = `Summary: ${ok} ok, ${warn} warn, ${fail} fail`;\n\n  console.log(\"\");\n  console.log(report.hasFailures ? colors.red(summaryLine) : colors.green(summaryLine));\n}\n"],"mappings":";;;;;;AAMA,MAAM,gBAA6C;CACjD,IAAI;CACJ,MAAM;CACN,MAAM;AACR;;;;;AAMA,SAAS,eAAe,QAA6B;CACnD,MAAM,SAAS,cAAc;CAE7B,QAAQ,QAAR;EACE,KAAK,MACH,OAAO,OAAO,MAAM,MAAM;EAC5B,KAAK,QACH,OAAO,OAAO,OAAO,MAAM;EAC7B,KAAK,QACH,OAAO,OAAO,IAAI,MAAM;CAC5B;AACF;;;;;;;;AA8BA,SAAgB,YAAY,QAA4B;CACtD,KAAK,MAAM,UAAU,OAAO,SAAS;EACnC,MAAM,SAAS,eAAe,OAAO,MAAM;EAE3C,QAAQ,IAAI,GAAG,OAAO,GAAG,OAAO,KAAK,OAAO,IAAI,EAAE,IAAI,OAAO,QAAQ;CACvE;CAEA,MAAM,EAAE,IAAI,MAAM,SAAS,OAAO;CAClC,MAAM,cAAc,YAAY,GAAG,OAAO,KAAK,SAAS,KAAK;CAE7D,QAAQ,IAAI,EAAE;CACd,QAAQ,IAAI,OAAO,cAAc,OAAO,IAAI,WAAW,IAAI,OAAO,MAAM,WAAW,CAAC;AACtF"}
+{"version":3,"file":"format-report.mjs","names":[],"sources":["C:/Work/Warlock.js/core/src/cli/commands/doctor/format-report.ts"],"sourcesContent":["import { colors } from \"@mongez/copper\";\nimport type { CheckStatus, DoctorReport } from \"./check.types\";\n\n/**\n * The glyph shown beside each check, keyed by status.\n */\nconst STATUS_SYMBOL: Record<CheckStatus, string> = {\n  ok: \"✓\",\n  warn: \"⚠\",\n  fail: \"✗\",\n};\n\n/**\n * Colorize a status glyph. Kept separate from {@link STATUS_SYMBOL} so the\n * plain glyphs remain available for snapshot-friendly, color-free assertions.\n */\nfunction colorizeSymbol(status: CheckStatus): string {\n  const symbol = STATUS_SYMBOL[status];\n\n  switch (status) {\n    case \"ok\":\n      return colors.green(symbol);\n    case \"warn\":\n      return colors.yellow(symbol);\n    case \"fail\":\n      return colors.red(symbol);\n  }\n}\n\n/**\n * Build the report body as an ordered list of plain (uncolored) lines:\n * one `<symbol> <name>: <detail>` line per check, a blank line, then a summary\n * line. Returned as strings (not printed) so the formatting is unit-testable.\n *\n * @param report The aggregated doctor report.\n * @returns The lines to print, top to bottom.\n */\nexport function formatReportLines(report: DoctorReport): string[] {\n  const lines = report.results.map((result) => {\n    return `${STATUS_SYMBOL[result.status]} ${result.name}: ${result.detail}`;\n  });\n\n  const { ok, warn, fail } = report.summary;\n\n  lines.push(\"\");\n  lines.push(`Summary: ${ok} ok, ${warn} warn, ${fail} fail`);\n\n  return lines;\n}\n\n/**\n * Print the report to stdout with colored status glyphs and a colored summary\n * verdict. Thin wrapper over {@link formatReportLines} — the structured report\n * stays the source of truth for the exit code.\n *\n * @param report The aggregated doctor report.\n */\nexport function printReport(report: DoctorReport): void {\n  for (const result of report.results) {\n    const symbol = colorizeSymbol(result.status);\n\n    console.log(`${symbol} ${colors.bold(result.name)}: ${result.detail}`);\n  }\n\n  const { ok, warn, fail } = report.summary;\n  const summaryLine = `Summary: ${ok} ok, ${warn} warn, ${fail} fail`;\n\n  console.log(\"\");\n  console.log(report.hasFailures ? colors.red(summaryLine) : colors.green(summaryLine));\n}\n"],"mappings":";;;;;;AAMA,MAAM,gBAA6C;CACjD,IAAI;CACJ,MAAM;CACN,MAAM;AACR;;;;;AAMA,SAAS,eAAe,QAA6B;CACnD,MAAM,SAAS,cAAc;CAE7B,QAAQ,QAAR;EACE,KAAK,MACH,OAAO,OAAO,MAAM,MAAM;EAC5B,KAAK,QACH,OAAO,OAAO,OAAO,MAAM;EAC7B,KAAK,QACH,OAAO,OAAO,IAAI,MAAM;CAC5B;AACF;;;;;;;;AA8BA,SAAgB,YAAY,QAA4B;CACtD,KAAK,MAAM,UAAU,OAAO,SAAS;EACnC,MAAM,SAAS,eAAe,OAAO,MAAM;EAE3C,QAAQ,IAAI,GAAG,OAAO,GAAG,OAAO,KAAK,OAAO,IAAI,EAAE,IAAI,OAAO,QAAQ;CACvE;CAEA,MAAM,EAAE,IAAI,MAAM,SAAS,OAAO;CAClC,MAAM,cAAc,YAAY,GAAG,OAAO,KAAK,SAAS,KAAK;CAE7D,QAAQ,IAAI,EAAE;CACd,QAAQ,IAAI,OAAO,cAAc,OAAO,IAAI,WAAW,IAAI,OAAO,MAAM,WAAW,CAAC;AACtF"}

package/esm/cli/commands/doctor/run-checks.mjs

@@ -1,13 +1,16 @@
-//#region ../core/src/cli/commands/doctor/run-checks.ts
+//#region core/src/cli/commands/doctor/run-checks.ts
 /**
 * Run one check defensively: a check that throws (or rejects) is recorded as a
 * `fail` carrying the error message, never re-thrown. This is what keeps
 * `doctor` itself crash-proof — a broken probe degrades to a failed check
 * instead of taking the whole command down.
+*
+* A check that returns `undefined` does not apply to this project; the caller
+* drops it from the report rather than printing a line about nothing.
 */
-async function runOne(check) {
+async function runOne(check, context) {
 	try {
-		return await check.run();
+		return await check.run(context);
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
 		return {
@@ -20,16 +23,22 @@ async function runOne(check) {
 /**
 * Run every check and aggregate the results into a {@link DoctorReport}.
 *
-* Checks run in registration order. Each is isolated via {@link runOne}, so one
-* throwing check cannot abort the others. The exit code is `1` if any check
+* Checks run in registration order against ONE shared boot context, so the
+* report can never contain two checks that disagree about the app because they
+* inspected it at different moments. Each is isolated via {@link runOne}, so
+* one throwing check cannot abort the others. The exit code is `1` if any check
 * resolved to `fail`, otherwise `0` — warnings never fail the command.
 *
 * @param checks The diagnostic probes to execute.
+* @param context What the boot pass observed.
 * @returns The aggregated report (results + per-status counts + exit code).
 */
-async function runChecks(checks) {
+async function runChecks(checks, context) {
 	const results = [];
-	for (const check of checks) results.push(await runOne(check));
+	for (const check of checks) {
+		const result = await runOne(check, context);
+		if (result) results.push(result);
+	}
 	const summary = {
 		ok: 0,
 		warn: 0,