@astroscope/health 0.1.0 → 0.2.1

package/README.md

@@ -2,7 +2,9 @@
 
 > **Note:** This package is in active development. APIs may change between versions.
 
-Kubernetes-style health check endpoints for Astro SSR. Provides `/livez`, `/readyz`, `/startupz`, and `/healthz` probes on a separate HTTP server.
+Kubernetes-style health check endpoints for Astro SSR. Provides `/livez`, `/readyz`, `/startupz`, and `/healthz` probes on a separate HTTP server. Automatically manages probe lifecycle via [@astroscope/boot](../boot).
+
+[health-probes](https://github.com/smnbbrv/health-probes) is used under the hood. If you need more control, you can use it directly in your boot file instead of this integration.
 
 ## Examples
 
@@ -16,78 +18,132 @@ npm install @astroscope/health
 
 ## Usage
 
-This package is designed to work with [@astroscope/boot](../boot) for lifecycle management.
+### 1. Add both integrations to your Astro config
+
+**Important:** `health()` must come **after** `boot()` in the integrations array.
 
 ```ts
-// src/boot.ts
-import type { BootContext } from "@astroscope/boot";
-import { checks, probes, server } from "@astroscope/health";
+// astro.config.ts
+import { defineConfig } from 'astro/config';
+import node from '@astrojs/node';
+import boot from '@astroscope/boot';
+import health from '@astroscope/health';
+
+export default defineConfig({
+  adapter: node({ mode: 'standalone' }),
+  integrations: [
+    boot(),
+    // in k8s use '0.0.0.0' to allow kubelet to access probes
+    // do not expose the health server publicly unless necessary
+    // by default is 127.0.0.1 for security reasons
+    health({ host: '0.0.0.0' }),
+  ],
+});
+```
 
-export async function onStartup({ dev, host, port }: BootContext) {
-  // start health server on a separate port
-  server.start({ port: 9090 });
+This would set up the health server in production mode, disabled in dev mode by default.
 
-  // enable liveness immediately
-  probes.livez.enable();
+### 2. Register health checks in your boot file
 
-  // initialize your app...
+The health server and probe lifecycle are managed automatically — you only need to register your health checks:
+
+```ts
+// src/boot.ts
+import type { BootContext } from '@astroscope/boot';
+import { checks } from '@astroscope/health';
+
+export async function onStartup({ dev, host, port }: BootContext) {
   await connectToDatabase();
 
   // register health checks
-  checks.register("database", () => db.ping());
+  checks.register('database', () => ({
+    status: db.isConnected() ? 'healthy' : 'unhealthy',
+    error: db.isConnected() ? undefined : 'connection lost',
+  }));
 
-  // enable startup probe (initialization complete)
-  probes.startupz.enable();
-
-  // enable readiness probe (ready for traffic)
-  probes.readyz.enable();
+  console.log(`Server ready at ${host}:${port}`);
 }
 
 export async function onShutdown() {
-  // disable readiness first (stop receiving traffic)
-  probes.readyz.disable();
-
   await disconnectFromDatabase();
-
-  // stop health server
-  await server.stop();
 }
 ```
 
-## Probes
+### What happens automatically
 
-### `/livez` — Liveness Probe
+The integration hooks into boot lifecycle events to manage probes:
+
+1. **Before `onStartup`**: health server starts, liveness probe enabled
+2. **After `onStartup`**: startup and readiness probes enabled
+3. **Before `onShutdown`**: readiness probe disabled (stops receiving traffic)
+4. **After `onShutdown`**: health server stopped
 
-Indicates if the process is running. If this fails, Kubernetes will restart the container.
+This ensures Kubernetes sees the correct state at each phase — liveness is available immediately, readiness only after your app has fully initialized, and traffic stops before shutdown begins.
+
+## Options
 
 ```ts
-probes.livez.enable(); // returns 200 OK
-probes.livez.disable(); // returns 503 Service Unavailable
+health({
+  host: '0.0.0.0', // default: "127.0.0.1"
+  port: 9090, // default: 9090
+  paths: SimplePaths, // default: K8sPaths
+  dev: true, // default: false
+});
 ```
 
-### `/startupz` — Startup Probe
+### `host`
 
-Indicates if the application has finished initializing. Kubernetes waits for this before sending traffic or checking liveness.
+Host to bind the health server to. Defaults to `127.0.0.1` (localhost only). Set to `0.0.0.0` when probes need to be reachable from outside the host, e.g. in Kubernetes where the kubelet sends requests to the pod IP.
+
+- **Type**: `string`
+- **Default**: `"127.0.0.1"`
+
+### `port`
+
+Port for the health server.
+
+- **Type**: `number`
+- **Default**: `9090`
+
+### `paths`
+
+Probe endpoint paths. Two presets are available:
+
+- `K8sPaths` (default): `/livez`, `/readyz`, `/startupz`, `/healthz`
+- `SimplePaths`: `/live`, `/ready`, `/startup`, `/health`
 
 ```ts
-probes.startupz.enable();
-probes.startupz.disable();
+import health, { SimplePaths } from '@astroscope/health';
+
+health({ paths: SimplePaths });
 ```
 
+### `dev`
+
+Enable the health server in development mode. By default, health probes only run in production builds.
+
+- **Type**: `boolean`
+- **Default**: `false`
+
+## Probes
+
+### `/livez` — Liveness Probe
+
+Indicates if the process is running. If this fails, Kubernetes restarts the container.
+
+### `/startupz` — Startup Probe
+
+Indicates if the application has finished initializing. Kubernetes waits for this before sending traffic or checking liveness.
+
 ### `/readyz` — Readiness Probe
 
 Indicates if the application is ready to receive traffic. When disabled or when required health checks fail, Kubernetes removes the pod from load balancer rotation.
 
-```ts
-probes.readyz.enable();
-probes.readyz.disable();
-```
-
 The readiness probe automatically runs all non-optional health checks and returns 503 if any fail.
 
 ### `/healthz` — Health Status
 
-Returns detailed JSON status of all probes and health checks. Useful for debugging and dashboards.
+Returns detailed JSON status of all probes and health checks:
 
 ```json
 {
@@ -112,6 +168,7 @@ Returns detailed JSON status of all probes and health checks. Useful for debuggi
 ```
 
 Status values:
+
 - `healthy` — all checks pass
 - `degraded` — optional checks failing, required checks pass
 - `unhealthy` — required checks failing
@@ -121,29 +178,30 @@ Status values:
 Register health checks to verify dependencies are working:
 
 ```ts
-import { checks } from "@astroscope/health";
+import { checks } from '@astroscope/health';
 
 // return result (recommended for boolean checks)
-checks.register("database", () => ({
-  status: db.isConnected() ? "healthy" : "unhealthy",
-  error: db.isConnected() ? undefined : "connection lost",
+checks.register('database', () => ({
+  status: db.isConnected() ? 'healthy' : 'unhealthy',
+  error: db.isConnected() ? undefined : 'connection lost',
 }));
 
 // throw-based (classic pattern)
-checks.register("cache", async () => {
+checks.register('cache', async () => {
   await redis.ping(); // throws if fails
 });
 
 // with options
 checks.register({
-  name: "external-api",
-  check: () => fetch("https://api.example.com/health").then(() => {}),
+  name: 'external-api',
+  check: () => fetch('https://api.example.com/health').then(() => {}),
   optional: true, // doesn't affect /readyz, only /healthz status
   timeout: 10000, // custom timeout (default: 5000ms)
 });
 ```
 
 The check function can either:
+
 - Return `HealthCheckResult` with status and optional error
 - Return `void` (completing without error = healthy)
 - Throw an error (= unhealthy with error message)
@@ -153,24 +211,12 @@ The check function can either:
 `register()` returns an unregister function:
 
 ```ts
-const unregister = checks.register({
-  name: "database",
-  check: () => db.ping(),
-});
+const unregister = checks.register('database', () => db.ping());
 
 // later...
 unregister();
 ```
 
-## Server Options
-
-```ts
-server.start({
-  host: "0.0.0.0", // default: "localhost"
-  port: 9090, // default: 9090
-});
-```
-
 ## Kubernetes Configuration
 
 ```yaml
@@ -201,83 +247,6 @@ spec:
         periodSeconds: 5
 ```
 
-## API Reference
-
-### Server
-
-```ts
-import { server } from "@astroscope/health";
-
-server.start(options?: HealthServerOptions): void;
-server.stop(): Promise<void>;
-```
-
-### Probes
-
-```ts
-import { probes } from "@astroscope/health";
-
-probes.livez.enable(): void;
-probes.livez.disable(): void;
-probes.livez.get(): Promise<HealthProbeResult>;
-probes.livez.response(): Promise<Response>;
-
-// same for startupz, readyz
-
-probes.healthz.get(): Promise<HealthzResult>;
-probes.healthz.response(): Promise<Response>;
-```
-
-### Checks
-
-```ts
-import { checks } from "@astroscope/health";
-
-checks.register(name: string, check: CheckFn): () => void;
-checks.register(check: HealthCheck): () => void;
-
-// CheckFn = () => Promise<HealthCheckResult | void> | HealthCheckResult | void
-checks.getChecks(): HealthCheck[];
-checks.runAll(): Promise<Record<string, HealthCheckResult>>;
-checks.runRequired(): Promise<boolean>;
-```
-
-## Types
-
-```ts
-interface HealthCheck {
-  name: string;
-  check: () => Promise<HealthCheckResult | void> | HealthCheckResult | void;
-  optional?: boolean; // default: false
-  timeout?: number; // default: 5000
-}
-
-interface HealthCheckResult {
-  status: "healthy" | "unhealthy";
-  latency?: number;
-  error?: string;
-}
-
-interface HealthProbeResult {
-  passing: boolean;
-}
-
-interface HealthzResult {
-  status: "healthy" | "degraded" | "unhealthy";
-  probes: {
-    livez: boolean;
-    startupz: boolean;
-    readyz: boolean;
-  };
-  checks: Record<string, HealthCheckResult>;
-}
-
-interface HealthServerOptions {
-  host?: string; // default: "localhost"
-  port?: number; // default: 9090
-}
-```
-
 ## License
 
 MIT

package/dist/chunk-VKEMDBBI.js

@@ -0,0 +1,23 @@
+// src/register.ts
+import { on } from "@astroscope/boot/events";
+import { probes, server } from "health-probes";
+function registerHealth(config) {
+  on("beforeOnStartup", () => {
+    server.start(config);
+    probes.live.enable();
+  });
+  on("afterOnStartup", () => {
+    probes.startup.enable();
+    probes.ready.enable();
+  });
+  on("beforeOnShutdown", () => {
+    probes.ready.disable();
+  });
+  on("afterOnShutdown", async () => {
+    await server.stop();
+  });
+}
+
+export {
+  registerHealth
+};

package/dist/index.d.ts

@@ -1,10 +1,11 @@
-/**
- * Server configuration options.
- */
-interface HealthServerOptions {
+import { AstroIntegration } from 'astro';
+import { ProbePaths } from 'health-probes';
+export { HealthCheck, HealthCheckResult, K8sPaths, ProbePaths, SimplePaths, checks } from 'health-probes';
+
+interface HealthOptions {
     /**
      * Host to bind the health server to.
-     * @default 'localhost'
+     * @default '127.0.0.1'
      */
     host?: string | undefined;
     /**
@@ -12,152 +13,26 @@ interface HealthServerOptions {
      * @default 9090
      */
     port?: number | undefined;
-}
-/**
- * Health check definition.
- */
-interface HealthCheck {
-    /**
-     * Unique name for this health check.
-     */
-    name: string;
     /**
-     * Function that performs the health check.
-     * Return HealthCheckResult or throw an error to indicate status.
-     * Returning void or completing without error means healthy.
+     * Custom paths for probe endpoints.
+     * @default K8sPaths (from health-probes)
      */
-    check: () => Promise<HealthCheckResult | void> | HealthCheckResult | void;
+    paths?: ProbePaths | undefined;
     /**
-     * Whether this check is optional.
-     * Optional checks don't affect the /readyz endpoint.
+     * Enable health probes in dev mode.
+     * By default, health probes only run in production.
      * @default false
      */
-    optional?: boolean | undefined;
-    /**
-     * Maximum time in ms for the check to complete.
-     * @default 5000
-     */
-    timeout?: number | undefined;
-}
-/**
- * Result of a single health check.
- */
-interface HealthCheckResult {
-    status: 'healthy' | 'unhealthy';
-    latency?: number | undefined;
-    error?: string | undefined;
-}
-/**
- * Result of a probe query.
- */
-interface HealthProbeResult {
-    passing: boolean;
+    dev?: boolean | undefined;
 }
 /**
- * Full health status including all checks.
+ * Astro integration for Kubernetes-style health probes.
+ *
+ * Automatically starts a health probe server after `onStartup` and stops it before `onShutdown`.
+ * Uses the `health-probes` package under the hood.
+ *
+ * Requires `@astroscope/boot` to be configured.
  */
-interface HealthzResult {
-    status: 'healthy' | 'degraded' | 'unhealthy';
-    probes: {
-        livez: boolean;
-        startupz: boolean;
-        readyz: boolean;
-    };
-    checks: Record<string, HealthCheckResult>;
-}
-/**
- * Single probe interface.
- */
-interface HealthProbe {
-    /**
-     * Enable this probe (will return 200 when called).
-     */
-    enable(): void;
-    /**
-     * Disable this probe (will return 503 when called).
-     */
-    disable(): void;
-    /**
-     * Get the current probe result.
-     */
-    get(): Promise<HealthProbeResult>;
-    /**
-     * Get a Response object for this probe.
-     */
-    response(): Promise<Response>;
-}
-/**
- * Healthz probe interface (always returns data, used for debugging).
- */
-interface HealthzProbe {
-    /**
-     * Get the full health status.
-     */
-    get(): Promise<HealthzResult>;
-    /**
-     * Get a Response object with JSON health data.
-     */
-    response(): Promise<Response>;
-}
-
-/**
- * Manages the HTTP server for health endpoints.
- */
-declare class HealthServer {
-    private instance;
-    /**
-     * Start the health check HTTP server.
-     */
-    start(options?: HealthServerOptions): void;
-    /**
-     * Stop the health check HTTP server.
-     */
-    stop(): Promise<void>;
-    private handleRequest;
-}
-declare const server: HealthServer;
-
-/**
- * Manages probe state and provides probe endpoints.
- */
-declare class HealthProbes {
-    private state;
-    private createProbeResponse;
-    readonly livez: HealthProbe;
-    readonly startupz: HealthProbe;
-    readonly readyz: HealthProbe;
-    readonly healthz: HealthzProbe;
-}
-declare const probes: HealthProbes;
-
-/**
- * Manages health check registration and execution.
- */
-declare class HealthChecks {
-    private readonly registered;
-    /**
-     * Register a health check.
-     * Returns an unregister function.
-     */
-    register(name: string, check: () => Promise<HealthCheckResult | void> | HealthCheckResult | void): () => void;
-    register(check: HealthCheck): () => void;
-    /**
-     * Run a single check with timeout.
-     */
-    private run;
-    /**
-     * Run all registered health checks.
-     */
-    runAll(): Promise<Record<string, HealthCheckResult>>;
-    /**
-     * Run only required checks and return whether they all pass.
-     */
-    runRequired(): Promise<boolean>;
-    /**
-     * Get all registered checks.
-     */
-    getChecks(): HealthCheck[];
-}
-declare const checks: HealthChecks;
+declare function health(options?: HealthOptions): AstroIntegration;
 
-export { type HealthCheck, type HealthCheckResult, HealthChecks, type HealthProbe, type HealthProbeResult, HealthProbes, HealthServer, type HealthServerOptions, type HealthzProbe, type HealthzResult, checks, probes, server };
+export { type HealthOptions, health as default };

package/dist/index.js

@@ -1,236 +1,69 @@
-// src/server.ts
-import { createServer } from "http";
+import {
+  registerHealth
+} from "./chunk-VKEMDBBI.js";
 
-// src/checks.ts
-var DEFAULT_TIMEOUT = 5e3;
-var HealthChecks = class {
-  registered = /* @__PURE__ */ new Map();
-  register(nameOrCheck, checkFn) {
-    const check = typeof nameOrCheck === "string" ? { name: nameOrCheck, check: checkFn } : nameOrCheck;
-    if (this.registered.has(check.name)) {
-      console.warn(`[health] overwriting existing check "${check.name}"`);
-    }
-    this.registered.set(check.name, check);
-    return () => {
-      this.registered.delete(check.name);
-    };
-  }
-  /**
-   * Run a single check with timeout.
-   */
-  async run(check) {
-    const timeout = check.timeout ?? DEFAULT_TIMEOUT;
-    const start = performance.now();
-    try {
-      const result = await Promise.race([
-        Promise.resolve(check.check()),
-        new Promise((_, reject) => {
-          setTimeout(() => reject(new Error(`check "${check.name}" timed out after ${timeout}ms`)), timeout);
-        })
-      ]);
-      const latency = Math.round(performance.now() - start);
-      if (result) {
-        return { ...result, latency };
-      }
-      return { status: "healthy", latency };
-    } catch (error) {
-      const latency = Math.round(performance.now() - start);
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      return { status: "unhealthy", latency, error: errorMessage };
-    }
-  }
-  /**
-   * Run all registered health checks.
-   */
-  async runAll() {
-    const results = {};
-    const checks2 = [...this.registered.values()];
-    const checkPromises = checks2.map(async (check) => {
-      const result = await this.run(check);
-      results[check.name] = result;
-    });
-    await Promise.all(checkPromises);
-    return results;
-  }
-  /**
-   * Run only required checks and return whether they all pass.
-   */
-  async runRequired() {
-    const requiredChecks = [...this.registered.values()].filter((check) => !check.optional);
-    if (requiredChecks.length === 0) {
-      return true;
-    }
-    const checkPromises = requiredChecks.map(async (check) => {
-      const result = await this.run(check);
-      return result.status === "healthy";
-    });
-    const results = await Promise.all(checkPromises);
-    return results.every(Boolean);
-  }
-  /**
-   * Get all registered checks.
-   */
-  getChecks() {
-    return [...this.registered.values()];
-  }
-};
-var checks = new HealthChecks();
-
-// src/probes.ts
-var HealthProbes = class {
-  state = {
-    livez: false,
-    startupz: false,
-    readyz: false
-  };
-  createProbeResponse(result) {
-    return new Response(result.passing ? "OK" : "Service Unavailable", {
-      status: result.passing ? 200 : 503,
-      headers: { "Content-Type": "text/plain" }
-    });
-  }
-  livez = {
-    enable: () => {
-      this.state.livez = true;
-    },
-    disable: () => {
-      this.state.livez = false;
-    },
-    get: async () => {
-      return { passing: this.state.livez };
-    },
-    response: async () => {
-      return this.createProbeResponse(await this.livez.get());
-    }
-  };
-  startupz = {
-    enable: () => {
-      this.state.startupz = true;
-    },
-    disable: () => {
-      this.state.startupz = false;
-    },
-    get: async () => {
-      return { passing: this.state.startupz };
-    },
-    response: async () => {
-      return this.createProbeResponse(await this.startupz.get());
-    }
-  };
-  readyz = {
-    enable: () => {
-      this.state.readyz = true;
-    },
-    disable: () => {
-      this.state.readyz = false;
-    },
-    get: async () => {
-      return { passing: this.state.readyz ? await checks.runRequired() : false };
-    },
-    response: async () => {
-      return this.createProbeResponse(await this.readyz.get());
-    }
+// src/index.ts
+import MagicString from "magic-string";
+import { checks, K8sPaths, SimplePaths } from "health-probes";
+function health(options = {}) {
+  const enableDev = options.dev ?? false;
+  const serverOptions = {
+    host: options.host ?? "127.0.0.1",
+    port: options.port ?? 9090,
+    ...options.paths && { paths: options.paths }
   };
-  healthz = {
-    get: async () => {
-      const checkResults = await checks.runAll();
-      const registered = checks.getChecks();
-      const hasUnhealthy = Object.values(checkResults).some((c) => c.status === "unhealthy");
-      const hasRequiredUnhealthy = registered.filter((check) => !check.optional).some((check) => checkResults[check.name]?.status !== "healthy");
-      let status = "healthy";
-      if (hasRequiredUnhealthy) {
-        status = "unhealthy";
-      } else if (hasUnhealthy) {
-        status = "degraded";
-      }
-      return {
-        status,
-        probes: { livez: this.state.livez, startupz: this.state.startupz, readyz: this.state.readyz },
-        checks: checkResults
-      };
-    },
-    response: async () => {
-      const result = await this.healthz.get();
-      return new Response(JSON.stringify(result, null, 2), {
-        status: 200,
-        headers: { "Content-Type": "application/json" }
-      });
-    }
-  };
-};
-var probes = new HealthProbes();
-
-// src/server.ts
-var HealthServer = class {
-  instance = null;
-  /**
-   * Start the health check HTTP server.
-   */
-  start(options = {}) {
-    if (this.instance) {
-      return;
-    }
-    const host = options.host ?? "localhost";
-    const port = options.port ?? 9090;
-    const instance = createServer(async (req, res) => {
-      try {
-        const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
-        const response = await this.handleRequest(url.pathname);
-        res.statusCode = response.status;
-        for (const [key, value] of response.headers.entries()) {
-          res.setHeader(key, value);
+  return {
+    name: "@astroscope/health",
+    hooks: {
+      "astro:config:setup": ({ config, command, updateConfig }) => {
+        const bootIndex = config.integrations.findIndex((i) => i.name === "@astroscope/boot");
+        const healthIndex = config.integrations.findIndex((i) => i.name === "@astroscope/health");
+        if (bootIndex === -1) {
+          throw new Error(
+            "@astroscope/health requires @astroscope/boot. Add boot() before health() in your integrations array."
+          );
         }
-        const body = await response.text();
-        res.end(body);
-      } catch {
-        res.statusCode = 500;
-        res.setHeader("Content-Type", "text/plain");
-        res.end("Internal Server Error");
-      }
-    });
-    instance.listen(port, host);
-    this.instance = instance;
-  }
-  /**
-   * Stop the health check HTTP server.
-   */
-  stop() {
-    return new Promise((resolve, reject) => {
-      if (!this.instance) {
-        resolve();
-        return;
-      }
-      this.instance.close((err) => {
-        if (err) {
-          reject(err);
-        } else {
-          this.instance = null;
-          resolve();
+        if (healthIndex !== -1 && bootIndex > healthIndex) {
+          throw new Error(
+            "@astroscope/health must come after @astroscope/boot. Swap the order in your integrations array."
+          );
         }
-      });
-    });
-  }
-  async handleRequest(pathname) {
-    switch (pathname) {
-      case "/livez":
-        return probes.livez.response();
-      case "/startupz":
-        return probes.startupz.response();
-      case "/readyz":
-        return probes.readyz.response();
-      case "/healthz":
-        return probes.healthz.response();
-      default:
-        return new Response("Not Found", { status: 404 });
+        const isBuild = command === "build";
+        updateConfig({
+          vite: {
+            plugins: [
+              {
+                name: "@astroscope/health",
+                configureServer() {
+                  if (!enableDev) return;
+                  registerHealth(serverOptions);
+                },
+                generateBundle(_, bundle) {
+                  if (!isBuild) return;
+                  const entryChunk = bundle["entry.mjs"];
+                  if (!entryChunk || entryChunk.type !== "chunk") return;
+                  const s = new MagicString(entryChunk.code);
+                  s.prepend(
+                    `import { registerHealth as __astroscope_registerHealth } from '@astroscope/health/setup';
+__astroscope_registerHealth(${JSON.stringify(serverOptions)});
+`
+                  );
+                  entryChunk.code = s.toString();
+                  if (entryChunk.map) {
+                    entryChunk.map = s.generateMap({ hires: true });
+                  }
+                }
+              }
+            ]
+          }
+        });
+      }
     }
-  }
-};
-var server = new HealthServer();
+  };
+}
 export {
-  HealthChecks,
-  HealthProbes,
-  HealthServer,
+  K8sPaths,
+  SimplePaths,
   checks,
-  probes,
-  server
+  health as default
 };

package/dist/register.d.ts

@@ -0,0 +1,5 @@
+import { HealthServerOptions } from 'health-probes';
+
+declare function registerHealth(config: HealthServerOptions): void;
+
+export { registerHealth };

package/dist/register.js

@@ -0,0 +1,6 @@
+import {
+  registerHealth
+} from "./chunk-VKEMDBBI.js";
+export {
+  registerHealth
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@astroscope/health",
-  "version": "0.1.0",
-  "description": "Health check endpoints for Astro — livez, readyz, startupz probes",
+  "version": "0.2.1",
+  "description": "Kubernetes-style health probes integration for Astro",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -9,6 +9,10 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./setup": {
+      "types": "./dist/register.d.ts",
+      "import": "./dist/register.js"
     }
   },
   "files": [
@@ -41,13 +45,23 @@
   },
   "homepage": "https://github.com/smnbbrv/astroscope/tree/main/packages/health#readme",
   "scripts": {
-    "build": "tsup src/index.ts --format esm --dts",
+    "build": "tsup src/index.ts src/register.ts --format esm --dts",
     "typecheck": "tsc --noEmit",
     "lint": "eslint 'src/**/*.ts'",
     "lint:fix": "eslint 'src/**/*.ts' --fix"
   },
+  "dependencies": {
+    "health-probes": "^1.0.0",
+    "magic-string": "^0.30.21"
+  },
   "devDependencies": {
+    "@astroscope/boot": "workspace:*",
+    "astro": "^5.17.1",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "@astroscope/boot": ">=0.3.2",
+    "astro": "^5.0.0"
   }
 }