@warlock.js/core 4.5.0 → 4.6.1

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

@@ -0,0 +1,28 @@
+import { connectorsManager } from "../../../../connectors/connectors-manager.mjs";
+
+//#region ../@warlock.js/core/src/cli/commands/doctor/checks/connectors.check.ts
+/**
+* Reports which connectors are registered and which are currently active. This
+* is informational: a registered-but-inactive connector is normal (it simply
+* has no config wired), so the check passes as long as the manager can be
+* enumerated and reports its active set.
+*
+* Read-only: calls `connectorsManager.list()` and each connector's
+* `isActive()` (a pure getter) only.
+*/
+const connectorsCheck = {
+	name: "connectors",
+	run: () => {
+		const connectors = connectorsManager.list();
+		const activeNames = connectors.filter((connector) => connector.isActive()).map((connector) => connector.name);
+		return {
+			name: "connectors",
+			status: "ok",
+			detail: activeNames.length > 0 ? `${connectors.length} registered, active: ${activeNames.join(", ")}` : `${connectors.length} registered, none active`
+		};
+	}
+};
+
+//#endregion
+export { connectorsCheck };
+//# sourceMappingURL=connectors.check.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"connectors.check.mjs","names":[],"sources":["../../../../../../../../../../@warlock.js/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"}

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

@@ -0,0 +1,35 @@
+import { config } from "../../../../config/config-getter.mjs";
+
+//#region ../@warlock.js/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.
+*
+* 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.
+*
+* Read-only: inspects `config.get("http.health")` only.
+*/
+const healthCheck = {
+	name: "health",
+	run: () => {
+		const healthConfig = config.get("http.health");
+		if (healthConfig?.enabled === false) return {
+			name: "health",
+			status: "warn",
+			detail: "health endpoints disabled (http.health.enabled = false)"
+		};
+		return {
+			name: "health",
+			status: "ok",
+			detail: `liveness ${healthConfig?.path ?? "/health"} + readiness ${healthConfig?.readinessPath ?? "/ready"} registered`
+		};
+	}
+};
+
+//#endregion
+export { healthCheck };
+//# sourceMappingURL=health.check.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"health.check.mjs","names":[],"sources":["../../../../../../../../../../@warlock.js/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"}

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

@@ -0,0 +1,25 @@
+import { configCheck } from "./config.check.mjs";
+import { connectorsCheck } from "./connectors.check.mjs";
+import { healthCheck } from "./health.check.mjs";
+import { optionalPeersCheck } from "./optional-peers.check.mjs";
+import { releaseHygieneCheck } from "./release-hygiene.check.mjs";
+import { routesCheck } from "./routes.check.mjs";
+
+//#region ../@warlock.js/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, config, connectors,
+* peers, health), release hygiene last.
+*/
+const defaultDoctorChecks = [
+	routesCheck,
+	configCheck,
+	connectorsCheck,
+	optionalPeersCheck,
+	healthCheck,
+	releaseHygieneCheck
+];
+
+//#endregion
+export { defaultDoctorChecks };
+//# sourceMappingURL=index.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../../../../../../../../@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 { 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, config, connectors,\n * peers, health), release hygiene last.\n */\nexport const defaultDoctorChecks: DoctorCheck[] = [\n  routesCheck,\n  configCheck,\n  connectorsCheck,\n  optionalPeersCheck,\n  healthCheck,\n  releaseHygieneCheck,\n];\n"],"mappings":";;;;;;;;;;;;;AAaA,MAAa,sBAAqC;CAChD;CACA;CACA;CACA;CACA;CACA;AACF"}

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

@@ -0,0 +1,90 @@
+import { createRequire } from "node:module";
+
+//#region ../@warlock.js/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.
+*/
+const projectRequire = createRequire(`${process.cwd()}/package.json`);
+/**
+* Whether a package can be resolved from the project. A failed resolve (the
+* normal "not installed" case) is swallowed and reported as missing.
+*/
+function isInstalled(packageName) {
+	try {
+		projectRequire.resolve(packageName);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* 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`.
+*
+* Read-only: resolves module paths only; never imports or executes the peers.
+*/
+const optionalPeersCheck = {
+	name: "optional-peers",
+	run: () => {
+		const missing = OPTIONAL_PEERS.filter((peer) => !isInstalled(peer.package));
+		if (missing.length === 0) return {
+			name: "optional-peers",
+			status: "ok",
+			detail: `all ${OPTIONAL_PEERS.length} known optional peers installed`
+		};
+		return {
+			name: "optional-peers",
+			status: "warn",
+			detail: `not installed → unavailable: ${missing.map((peer) => `${peer.package} (${peer.feature})`).join("; ")}`
+		};
+	}
+};
+
+//#endregion
+export { optionalPeersCheck };
+//# sourceMappingURL=optional-peers.check.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"optional-peers.check.mjs","names":[],"sources":["../../../../../../../../../../@warlock.js/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"}

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

@@ -0,0 +1,69 @@
+import { rootPath } from "../../../../utils/paths.mjs";
+import { existsSync, readFileSync } from "node:fs";
+
+//#region ../@warlock.js/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.
+*/
+function parseTopHeading(changelog) {
+	const match = changelog.match(/^##\s+(\d+)\.(\d+)\.(\d+)(?:\s*[-–]\s*(\d{4}-\d{2}-\d{2}))?\s*$/m);
+	if (!match) return;
+	const [, major, minor, patch, date] = match;
+	return {
+		version: `${major}.${minor}.${patch}`,
+		date
+	};
+}
+/**
+* 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.
+*
+* Verdicts:
+* - no `CHANGELOG.md` → `warn` (a changelog is recommended, 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;
+		if (typeof pkgVersion !== "string") return {
+			name: "release-hygiene",
+			status: "fail",
+			detail: "package.json has no string version field"
+		};
+		if (!existsSync(changelogPath)) return {
+			name: "release-hygiene",
+			status: "warn",
+			detail: `no CHANGELOG.md at project root (package.json is ${pkgVersion})`
+		};
+		const heading = parseTopHeading(readFileSync(changelogPath, "utf8"));
+		if (!heading) return {
+			name: "release-hygiene",
+			status: "warn",
+			detail: "CHANGELOG.md has no parseable `## x.y.z` heading"
+		};
+		if (heading.version !== pkgVersion) return {
+			name: "release-hygiene",
+			status: "fail",
+			detail: `package.json ${pkgVersion} ≠ top CHANGELOG heading ${heading.version}`
+		};
+		return {
+			name: "release-hygiene",
+			status: "ok",
+			detail: `package.json and CHANGELOG agree on ${pkgVersion}`
+		};
+	}
+};
+
+//#endregion
+export { releaseHygieneCheck };
+//# sourceMappingURL=release-hygiene.check.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"release-hygiene.check.mjs","names":[],"sources":["../../../../../../../../../../@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 * 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"}

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

@@ -0,0 +1,30 @@
+import { router } from "../../../../router/router.mjs";
+
+//#region ../@warlock.js/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.
+*
+* Read-only: introspects the router via `routeCount()` only.
+*/
+const routesCheck = {
+	name: "routes",
+	run: () => {
+		const count = router.routeCount();
+		if (count === 0) return {
+			name: "routes",
+			status: "warn",
+			detail: "0 routes registered — did a route module fail to load?"
+		};
+		return {
+			name: "routes",
+			status: "ok",
+			detail: `${count} registered`
+		};
+	}
+};
+
+//#endregion
+export { routesCheck };
+//# sourceMappingURL=routes.check.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"routes.check.mjs","names":[],"sources":["../../../../../../../../../../@warlock.js/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"}

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

@@ -0,0 +1,28 @@
+import { defaultDoctorChecks } from "./checks/index.mjs";
+import { printReport } from "./format-report.mjs";
+import { runChecks } from "./run-checks.mjs";
+
+//#region ../@warlock.js/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.
+*
+* 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.
+*
+* @param _data Parsed CLI args (unused — doctor takes no positional args).
+*/
+async function doctorCommandAction(_data) {
+	const report = await runChecks(defaultDoctorChecks);
+	printReport(report);
+	if (report.hasFailures) process.exit(report.exitCode);
+}
+
+//#endregion
+export { doctorCommandAction };
+//# sourceMappingURL=doctor-command.action.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"doctor-command.action.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/core/src/cli/commands/doctor/doctor-command.action.ts"],"sourcesContent":["import type { CommandActionData } from \"../../types\";\nimport { defaultDoctorChecks } from \"./checks\";\nimport { printReport } from \"./format-report\";\nimport { runChecks } from \"./run-checks\";\n\n/**\n * Action behind `warlock doctor`. Runs the default read-only diagnostic\n * checks, prints the grouped pass/warn/fail report, and — when any check\n * failed — exits the process with a non-zero code so the command signals\n * failure to scripts/CI.\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.\n *\n * @param _data Parsed CLI args (unused — doctor takes no positional args).\n */\nexport async function doctorCommandAction(_data: CommandActionData): Promise<void> {\n  const report = await runChecks(defaultDoctorChecks);\n\n  printReport(report);\n\n  if (report.hasFailures) {\n    process.exit(report.exitCode);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAmBA,eAAsB,oBAAoB,OAAyC;CACjF,MAAM,SAAS,MAAM,UAAU,mBAAmB;CAElD,YAAY,MAAM;CAElB,IAAI,OAAO,aACT,QAAQ,KAAK,OAAO,QAAQ;AAEhC"}

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

@@ -0,0 +1,44 @@
+import { colors } from "@mongez/copper";
+
+//#region ../@warlock.js/core/src/cli/commands/doctor/format-report.ts
+/**
+* The glyph shown beside each check, keyed by status.
+*/
+const STATUS_SYMBOL = {
+	ok: "✓",
+	warn: "⚠",
+	fail: "✗"
+};
+/**
+* Colorize a status glyph. Kept separate from {@link STATUS_SYMBOL} so the
+* plain glyphs remain available for snapshot-friendly, color-free assertions.
+*/
+function colorizeSymbol(status) {
+	const symbol = STATUS_SYMBOL[status];
+	switch (status) {
+		case "ok": return colors.green(symbol);
+		case "warn": return colors.yellow(symbol);
+		case "fail": return colors.red(symbol);
+	}
+}
+/**
+* Print the report to stdout with colored status glyphs and a colored summary
+* verdict. Thin wrapper over {@link formatReportLines} — the structured report
+* stays the source of truth for the exit code.
+*
+* @param report The aggregated doctor report.
+*/
+function printReport(report) {
+	for (const result of report.results) {
+		const symbol = colorizeSymbol(result.status);
+		console.log(`${symbol} ${colors.bold(result.name)}: ${result.detail}`);
+	}
+	const { ok, warn, fail } = report.summary;
+	const summaryLine = `Summary: ${ok} ok, ${warn} warn, ${fail} fail`;
+	console.log("");
+	console.log(report.hasFailures ? colors.red(summaryLine) : colors.green(summaryLine));
+}
+
+//#endregion
+export { printReport };
+//# sourceMappingURL=format-report.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"format-report.mjs","names":[],"sources":["../../../../../../../../../@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

@@ -0,0 +1,50 @@
+//#region ../@warlock.js/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.
+*/
+async function runOne(check) {
+	try {
+		return await check.run();
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return {
+			name: check.name,
+			status: "fail",
+			detail: `check threw: ${message}`
+		};
+	}
+}
+/**
+* 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
+* resolved to `fail`, otherwise `0` — warnings never fail the command.
+*
+* @param checks The diagnostic probes to execute.
+* @returns The aggregated report (results + per-status counts + exit code).
+*/
+async function runChecks(checks) {
+	const results = [];
+	for (const check of checks) results.push(await runOne(check));
+	const summary = {
+		ok: 0,
+		warn: 0,
+		fail: 0
+	};
+	for (const result of results) summary[result.status] += 1;
+	const hasFailures = summary.fail > 0;
+	return {
+		results,
+		summary,
+		hasFailures,
+		exitCode: hasFailures ? 1 : 0
+	};
+}
+
+//#endregion
+export { runChecks };
+//# sourceMappingURL=run-checks.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"run-checks.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/core/src/cli/commands/doctor/run-checks.ts"],"sourcesContent":["import type { CheckResult, CheckStatus, DoctorCheck, DoctorReport } from \"./check.types\";\n\n/**\n * Run one check defensively: a check that throws (or rejects) is recorded as a\n * `fail` carrying the error message, never re-thrown. This is what keeps\n * `doctor` itself crash-proof — a broken probe degrades to a failed check\n * instead of taking the whole command down.\n */\nasync function runOne(check: DoctorCheck): Promise<CheckResult> {\n  try {\n    return await check.run();\n  } catch (error) {\n    const message = error instanceof Error ? error.message : String(error);\n\n    return {\n      name: check.name,\n      status: \"fail\",\n      detail: `check threw: ${message}`,\n    };\n  }\n}\n\n/**\n * Run every check and aggregate the results into a {@link DoctorReport}.\n *\n * Checks run in registration order. Each is isolated via {@link runOne}, so one\n * throwing check cannot abort the others. The exit code is `1` if any check\n * resolved to `fail`, otherwise `0` — warnings never fail the command.\n *\n * @param checks The diagnostic probes to execute.\n * @returns The aggregated report (results + per-status counts + exit code).\n */\nexport async function runChecks(checks: DoctorCheck[]): Promise<DoctorReport> {\n  const results: CheckResult[] = [];\n\n  for (const check of checks) {\n    results.push(await runOne(check));\n  }\n\n  const summary: Record<CheckStatus, number> = { ok: 0, warn: 0, fail: 0 };\n\n  for (const result of results) {\n    summary[result.status] += 1;\n  }\n\n  const hasFailures = summary.fail > 0;\n\n  return {\n    results,\n    summary,\n    hasFailures,\n    exitCode: hasFailures ? 1 : 0,\n  };\n}\n"],"mappings":";;;;;;;AAQA,eAAe,OAAO,OAA0C;CAC9D,IAAI;EACF,OAAO,MAAM,MAAM,IAAI;CACzB,SAAS,OAAO;EACd,MAAM,UAAU,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;EAErE,OAAO;GACL,MAAM,MAAM;GACZ,QAAQ;GACR,QAAQ,gBAAgB;EAC1B;CACF;AACF;;;;;;;;;;;AAYA,eAAsB,UAAU,QAA8C;CAC5E,MAAM,UAAyB,CAAC;CAEhC,KAAK,MAAM,SAAS,QAClB,QAAQ,KAAK,MAAM,OAAO,KAAK,CAAC;CAGlC,MAAM,UAAuC;EAAE,IAAI;EAAG,MAAM;EAAG,MAAM;CAAE;CAEvE,KAAK,MAAM,UAAU,SACnB,QAAQ,OAAO,WAAW;CAG5B,MAAM,cAAc,QAAQ,OAAO;CAEnC,OAAO;EACL;EACA;EACA;EACA,UAAU,cAAc,IAAI;CAC9B;AACF"}

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

@@ -0,0 +1,29 @@
+import { command } from "../cli-command.mjs";
+import { doctorCommandAction } from "./doctor/doctor-command.action.mjs";
+
+//#region ../@warlock.js/core/src/cli/commands/doctor.command.ts
+/**
+* `warlock doctor` — run a set of READ-ONLY diagnostic checks (routes, config,
+* connectors, optional peers, health endpoints, release hygiene) and print a
+* grouped pass/warn/fail report. Exits non-zero if any check fails.
+*
+* Preload plan: load every config file and bootstrap app code so routes and
+* connectors are registered for introspection, but DELIBERATELY start no
+* connectors — doctor must not open database/cache/socket connections. The
+* connectors check therefore reports the registered set and which (if any) are
+* already active without forcing them up.
+*/
+const doctorCommand = command({
+	name: "doctor",
+	description: "Run read-only health checks (routes, config, connectors, optional peers, health endpoints, release hygiene) and print a pass/warn/fail report",
+	action: doctorCommandAction,
+	preload: {
+		config: true,
+		env: true,
+		bootstrap: true
+	}
+});
+
+//#endregion
+export { doctorCommand };
+//# sourceMappingURL=doctor.command.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"doctor.command.mjs","names":[],"sources":["../../../../../../../../@warlock.js/core/src/cli/commands/doctor.command.ts"],"sourcesContent":["import { command } from \"../cli-command\";\nimport { doctorCommandAction } from \"./doctor/doctor-command.action\";\n\n/**\n * `warlock doctor` — run a set of READ-ONLY diagnostic checks (routes, config,\n * connectors, optional peers, health endpoints, release hygiene) and print a\n * grouped pass/warn/fail report. Exits non-zero if any check fails.\n *\n * Preload plan: load every config file and bootstrap app code so routes and\n * connectors are registered for introspection, but DELIBERATELY start no\n * connectors — doctor must not open database/cache/socket connections. The\n * connectors check therefore reports the registered set and which (if any) are\n * already active without forcing them up.\n */\nexport const doctorCommand = command({\n  name: \"doctor\",\n  description:\n    \"Run read-only health checks (routes, config, connectors, optional peers, health endpoints, release hygiene) and print a pass/warn/fail report\",\n  action: doctorCommandAction,\n  preload: {\n    config: true,\n    env: true,\n    bootstrap: true,\n  },\n});\n"],"mappings":";;;;;;;;;;;;;;;AAcA,MAAa,gBAAgB,QAAQ;CACnC,MAAM;CACN,aACE;CACF,QAAQ;CACR,SAAS;EACP,QAAQ;EACR,KAAK;EACL,WAAW;CACb;AACF,CAAC"}

package/esm/cli/commands/generate/templates/stubs.mjs

@@ -333,17 +333,15 @@ export default seeder({
   name: "Seed ${entity.plural.pascal}",
   once: true,
   enabled: true,
-  run: async () => {
+  run: async ({ track }) => {
     const total = 10;
     for (let i = 0; i < total; i++) {
-      await ${entity.singular.pascal}.create({
-        // TODO: Add more fields
-      });
+      track(
+        await ${entity.singular.pascal}.create({
+          // TODO: Add more fields
+        }),
+      );
     }
-
-    return {
-      recordsCreated: total,
-    };
   },
 });
 `;