@warlock.js/core 5.0.1 → 5.1.0

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":["../../../../../../../../../../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,CAAC,CAC3D,KAAK,IAAI;EAChB;EAGF,IAAI,CAAC,QAAQ,QACX;EAGF,MAAM,UAAU,WAAW,QACxB,KAAK,UAAU,aAAa,MAAM,KAAK,IAAI,MAAM,OAAO,EAAE,CAAC,CAC3D,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

@@ -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":["../../../../../../../../../../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,CAAC,CAAC,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
 /**
-* 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`
 		};
 	}
 };

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":["../../../../../../../../../../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,CAAC,CAAC,MAAM,UAAU;EACnC,MAAM,SAAS,OAAO,MAAM,MAAM,CAAC,CAAC,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,CAAC,CAAC,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,CAAC,CAAC,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,CAAC,CAAC,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

@@ -11,6 +11,11 @@ import { routesCheck } from "./routes.check.mjs";
 * 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":["../../../../../../../../../../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,50 +1,8 @@
+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"
-	}
-];
-/**
 * 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":["../../../../../../../../../../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,CAAC,CAAC,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,CAAC,CAAC,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,CAAC,CAAC,KAAK,IAAI;EACxF;EAGF,OAAO;GACL,MAAM;GACN;GACA,QAAQ,yCAAyC,SAC9C,KAAK,SAAS,KAAK,OAAO,CAAC,CAC3B,KAAK,IAAI,EAAE;EAChB;CACF;AACF"}

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

@@ -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":["../../../../../../../../../../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
 /**
-* 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.
+* 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 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})`
 		};
 	}
 };