@rely-net/sdk 1.0.0

package/README.md

@@ -0,0 +1,198 @@
+# @rely-net/sdk
+
+Official SDK for [rely.net](https://rely.net) — monitor your application from the inside.
+
+## What it does
+
+- Sends health check results from inside your app to rely.net
+- Tracks custom metrics alongside vendor status
+- Marks deployments on your monitoring charts
+- Captures request telemetry (error rate, response times)
+- Sends runtime stats (memory usage, uptime)
+
+## Installation
+
+```bash
+npm install @rely-net/sdk
+```
+
+## Quick start (Next.js)
+
+### 1. Get your API key
+
+Go to [rely.net/settings/api-keys](https://rely.net/settings/api-keys) and create a new key.
+
+### 2. Add to your environment
+
+```bash
+# .env.local
+RELY_API_KEY=rely_live_...
+```
+
+### 3. Create `instrumentation.ts`
+
+Create a file called `instrumentation.ts` in your Next.js project root:
+
+```ts
+import { Rely } from '@rely-net/sdk'
+
+export const rely = new Rely({
+  apiKey: process.env.RELY_API_KEY!,
+})
+
+// Add health checks for your services
+rely.healthCheck('database', async () => {
+  const { supabase } = await import('@/lib/supabase/client')
+  const { error } = await supabase.from('_health').select('1')
+  if (error) throw error
+})
+```
+
+That's it. The SDK will start sending data to rely.net within 60 seconds.
+
+## Health check examples
+
+Copy-paste snippets for common services:
+
+### Supabase
+
+```ts
+rely.healthCheck('supabase', async () => {
+  const { error } = await supabase.from('_health').select('1')
+  if (error) throw error
+})
+```
+
+### Stripe
+
+```ts
+rely.healthCheck('stripe', async () => {
+  await stripe.balance.retrieve()
+})
+```
+
+### Resend
+
+```ts
+rely.healthCheck('resend', async () => {
+  const res = await fetch('https://api.resend.com/domains', {
+    headers: { Authorization: `Bearer ${process.env.RESEND_API_KEY}` }
+  })
+  if (!res.ok) throw new Error(`Resend returned ${res.status}`)
+})
+```
+
+### Redis / Upstash
+
+```ts
+rely.healthCheck('redis', async () => {
+  await redis.ping()
+})
+```
+
+### PlanetScale / MySQL
+
+```ts
+rely.healthCheck('database', async () => {
+  await db.execute('SELECT 1')
+})
+```
+
+### OpenAI
+
+```ts
+rely.healthCheck('openai', async () => {
+  await openai.models.list()
+})
+```
+
+### Anthropic
+
+```ts
+rely.healthCheck('anthropic', async () => {
+  const res = await fetch('https://api.anthropic.com/v1/models', {
+    headers: { 'x-api-key': process.env.ANTHROPIC_API_KEY! }
+  })
+  if (!res.ok) throw new Error(`Anthropic returned ${res.status}`)
+})
+```
+
+## Custom metrics
+
+Send any numeric value to chart it in rely.net:
+
+```ts
+rely.metric('checkout.conversion_rate', 0.034)
+rely.metric('queue.depth', 142, { queue: 'email' })
+rely.metric('api.active_connections', 58)
+```
+
+Metrics are sent on the next flush (default: every 60 seconds).
+
+## Request telemetry (Next.js middleware)
+
+Automatically capture error rates and response times:
+
+```ts
+// middleware.ts (in your Next.js project root)
+import { withRelyMiddleware } from '@rely-net/sdk'
+import { rely } from './instrumentation'
+
+export default withRelyMiddleware(rely)
+
+export const config = {
+  matcher: ['/((?!_next/static|_next/image|favicon.ico).*)'],
+}
+```
+
+## Deployment markers
+
+Deployment markers are sent automatically when the SDK initializes. They appear as vertical lines on your charts in rely.net, making it easy to correlate issues with deploys.
+
+To send a manual deployment marker with custom metadata:
+
+```ts
+rely.deployment({
+  version: process.env.MY_APP_VERSION,
+  metadata: { team: 'backend', feature_flags: 'new-checkout' }
+})
+```
+
+## Configuration options
+
+```ts
+new Rely({
+  apiKey: string,           // required
+  baseUrl?: string,         // default: 'https://rely.net'
+  environment?: string,     // default: process.env.NODE_ENV
+  flushInterval?: number,   // default: 60000 (ms)
+  sanitizeErrors?: boolean, // default: true (recommended)
+  debug?: boolean,          // default: false
+})
+```
+
+## Security
+
+By default, the SDK automatically redacts common secret patterns from error messages before sending them to rely.net. This protects API keys, tokens, and passwords from being accidentally transmitted.
+
+Patterns redacted include:
+
+- Stripe API keys (`sk_live_`, `pk_live_`, etc.)
+- Bearer tokens
+- Passwords and secrets in error strings
+- AWS access key patterns
+- rely.net API keys
+
+Set `sanitizeErrors: false` only if you have verified your error messages never contain sensitive data.
+
+## TypeScript
+
+The SDK is written in TypeScript and ships with full type definitions. No `@types` package needed.
+
+```ts
+import type { HealthCheckFn, RelyClientOptions } from '@rely-net/sdk'
+```
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,133 @@
+declare const SDK_VERSION = "1.0.0";
+type Environment = "production" | "staging" | "development";
+type HealthCheckStatus = "passing" | "failing";
+type HealthCheckFn = () => Promise<void>;
+interface HealthCheckResult {
+    name: string;
+    status: HealthCheckStatus;
+    duration_ms: number;
+    error_message?: string;
+    stack_trace?: string;
+}
+interface DeploymentInfo {
+    version?: string;
+    environment?: string;
+    branch?: string;
+    commit_message?: string;
+    metadata?: Record<string, string>;
+}
+interface MetricDatapoint {
+    name: string;
+    value: number;
+    tags?: Record<string, string>;
+    unit?: string;
+}
+interface RuntimeStats {
+    memory_heap_used_mb: number;
+    memory_heap_total_mb: number;
+    memory_rss_mb: number;
+    cpu_usage_percent: number;
+    process_uptime_secs: number;
+    node_version: string;
+    region: string;
+}
+interface RouteStats {
+    route: string;
+    p95_ms: number;
+    count: number;
+}
+interface RequestWindowData {
+    window_start: string;
+    window_end: string;
+    total_requests: number;
+    status_2xx: number;
+    status_3xx: number;
+    status_4xx: number;
+    status_5xx: number;
+    p50_ms: number;
+    p95_ms: number;
+    p99_ms: number;
+    slowest_routes: RouteStats[];
+}
+interface DeploymentPayload {
+    version: string;
+    environment: string;
+    branch: string;
+    commit_message: string;
+    framework: string;
+    framework_version: string;
+    node_version: string;
+    region: string;
+    deployment_url: string;
+    metadata: Record<string, unknown>;
+}
+interface IngestPayload {
+    version: string;
+    timestamp: string;
+    deployment?: DeploymentPayload;
+    health_checks?: HealthCheckResult[];
+    metrics?: MetricDatapoint[];
+    runtime?: RuntimeStats;
+    request_telemetry?: RequestWindowData;
+}
+interface IngestResponse {
+    received: boolean;
+    processed: {
+        deployment: boolean;
+        health_checks: number;
+        metrics: number;
+        runtime: boolean;
+        request_telemetry: boolean;
+    };
+    warnings: string[];
+    timestamp: string;
+}
+interface RelyClientOptions {
+    apiKey: string;
+    baseUrl?: string;
+    environment?: Environment;
+    flushInterval?: number;
+    sanitizeErrors?: boolean;
+    debug?: boolean;
+}
+
+declare class RelyClient {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly environment;
+    private readonly flushInterval;
+    private readonly sanitizeErrors;
+    private readonly debug;
+    private healthChecks;
+    private pendingMetrics;
+    private requestBuffer;
+    private flushTimer;
+    private deploymentSent;
+    private isDestroyed;
+    constructor(options: RelyClientOptions);
+    healthCheck(name: string, fn: HealthCheckFn): this;
+    metric(name: string, value: number, tags?: Record<string, string>): this;
+    deployment(info: DeploymentInfo): void;
+    recordRequest(route: string, statusCode: number, durationMs: number): void;
+    flush(): Promise<void>;
+    destroy(): void;
+    private initialize;
+    private runHealthChecks;
+    private collectRuntimeStats;
+    private sendDeploymentMarker;
+    private sendPayload;
+    private sanitize;
+    private sanitizeTags;
+    private detectFrameworkVersion;
+    private log;
+}
+
+type NextMiddlewareResult = Response | undefined | null;
+type NextMiddleware = (request: Request, event: unknown) => NextMiddlewareResult | Promise<NextMiddlewareResult>;
+type WrappedMiddleware = (request: Request, event: unknown) => Promise<NextMiddlewareResult>;
+declare function withRelyMiddleware(rely: RelyClient, middleware?: NextMiddleware): WrappedMiddleware;
+
+declare function createRelyClient(options: RelyClientOptions): RelyClient;
+declare function getRelyClient(): RelyClient;
+
+export { type DeploymentInfo, type Environment, type HealthCheckFn, type HealthCheckResult, type IngestPayload, type IngestResponse, type MetricDatapoint, RelyClient as Rely, RelyClient, type RelyClientOptions, type RequestWindowData, type RouteStats, type RuntimeStats, SDK_VERSION, createRelyClient, getRelyClient, withRelyMiddleware };

package/dist/index.d.ts

@@ -0,0 +1,133 @@
+declare const SDK_VERSION = "1.0.0";
+type Environment = "production" | "staging" | "development";
+type HealthCheckStatus = "passing" | "failing";
+type HealthCheckFn = () => Promise<void>;
+interface HealthCheckResult {
+    name: string;
+    status: HealthCheckStatus;
+    duration_ms: number;
+    error_message?: string;
+    stack_trace?: string;
+}
+interface DeploymentInfo {
+    version?: string;
+    environment?: string;
+    branch?: string;
+    commit_message?: string;
+    metadata?: Record<string, string>;
+}
+interface MetricDatapoint {
+    name: string;
+    value: number;
+    tags?: Record<string, string>;
+    unit?: string;
+}
+interface RuntimeStats {
+    memory_heap_used_mb: number;
+    memory_heap_total_mb: number;
+    memory_rss_mb: number;
+    cpu_usage_percent: number;
+    process_uptime_secs: number;
+    node_version: string;
+    region: string;
+}
+interface RouteStats {
+    route: string;
+    p95_ms: number;
+    count: number;
+}
+interface RequestWindowData {
+    window_start: string;
+    window_end: string;
+    total_requests: number;
+    status_2xx: number;
+    status_3xx: number;
+    status_4xx: number;
+    status_5xx: number;
+    p50_ms: number;
+    p95_ms: number;
+    p99_ms: number;
+    slowest_routes: RouteStats[];
+}
+interface DeploymentPayload {
+    version: string;
+    environment: string;
+    branch: string;
+    commit_message: string;
+    framework: string;
+    framework_version: string;
+    node_version: string;
+    region: string;
+    deployment_url: string;
+    metadata: Record<string, unknown>;
+}
+interface IngestPayload {
+    version: string;
+    timestamp: string;
+    deployment?: DeploymentPayload;
+    health_checks?: HealthCheckResult[];
+    metrics?: MetricDatapoint[];
+    runtime?: RuntimeStats;
+    request_telemetry?: RequestWindowData;
+}
+interface IngestResponse {
+    received: boolean;
+    processed: {
+        deployment: boolean;
+        health_checks: number;
+        metrics: number;
+        runtime: boolean;
+        request_telemetry: boolean;
+    };
+    warnings: string[];
+    timestamp: string;
+}
+interface RelyClientOptions {
+    apiKey: string;
+    baseUrl?: string;
+    environment?: Environment;
+    flushInterval?: number;
+    sanitizeErrors?: boolean;
+    debug?: boolean;
+}
+
+declare class RelyClient {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly environment;
+    private readonly flushInterval;
+    private readonly sanitizeErrors;
+    private readonly debug;
+    private healthChecks;
+    private pendingMetrics;
+    private requestBuffer;
+    private flushTimer;
+    private deploymentSent;
+    private isDestroyed;
+    constructor(options: RelyClientOptions);
+    healthCheck(name: string, fn: HealthCheckFn): this;
+    metric(name: string, value: number, tags?: Record<string, string>): this;
+    deployment(info: DeploymentInfo): void;
+    recordRequest(route: string, statusCode: number, durationMs: number): void;
+    flush(): Promise<void>;
+    destroy(): void;
+    private initialize;
+    private runHealthChecks;
+    private collectRuntimeStats;
+    private sendDeploymentMarker;
+    private sendPayload;
+    private sanitize;
+    private sanitizeTags;
+    private detectFrameworkVersion;
+    private log;
+}
+
+type NextMiddlewareResult = Response | undefined | null;
+type NextMiddleware = (request: Request, event: unknown) => NextMiddlewareResult | Promise<NextMiddlewareResult>;
+type WrappedMiddleware = (request: Request, event: unknown) => Promise<NextMiddlewareResult>;
+declare function withRelyMiddleware(rely: RelyClient, middleware?: NextMiddleware): WrappedMiddleware;
+
+declare function createRelyClient(options: RelyClientOptions): RelyClient;
+declare function getRelyClient(): RelyClient;
+
+export { type DeploymentInfo, type Environment, type HealthCheckFn, type HealthCheckResult, type IngestPayload, type IngestResponse, type MetricDatapoint, RelyClient as Rely, RelyClient, type RelyClientOptions, type RequestWindowData, type RouteStats, type RuntimeStats, SDK_VERSION, createRelyClient, getRelyClient, withRelyMiddleware };

package/dist/index.js

@@ -0,0 +1,457 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Rely: () => RelyClient,
+  RelyClient: () => RelyClient,
+  SDK_VERSION: () => SDK_VERSION2,
+  createRelyClient: () => createRelyClient,
+  getRelyClient: () => getRelyClient,
+  withRelyMiddleware: () => withRelyMiddleware
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/collectors/requests.ts
+function percentile(arr, p) {
+  if (arr.length === 0) return 0;
+  const sorted = [...arr].sort((a, b) => a - b);
+  const index = Math.ceil(p / 100 * sorted.length) - 1;
+  return sorted[Math.max(0, index)];
+}
+var RequestBuffer = class {
+  constructor() {
+    this.routes = /* @__PURE__ */ new Map();
+    this.windowStart = /* @__PURE__ */ new Date();
+  }
+  record(route, statusCode, durationMs) {
+    const normalized = this.normalizeRoute(route);
+    if (!this.routes.has(normalized)) {
+      this.routes.set(normalized, { durations: [], statusCodes: [] });
+    }
+    const r = this.routes.get(normalized);
+    r.durations.push(Math.max(0, durationMs));
+    r.statusCodes.push(statusCode);
+  }
+  flush() {
+    const allDurations = [];
+    const allStatusCodes = [];
+    const routeStats = [];
+    for (const [route, data] of Array.from(this.routes.entries())) {
+      allDurations.push(...data.durations);
+      allStatusCodes.push(...data.statusCodes);
+      routeStats.push({
+        route,
+        p95_ms: percentile(data.durations, 95),
+        count: data.durations.length
+      });
+    }
+    const result = {
+      window_start: this.windowStart.toISOString(),
+      window_end: (/* @__PURE__ */ new Date()).toISOString(),
+      total_requests: allDurations.length,
+      status_2xx: allStatusCodes.filter((s) => s >= 200 && s < 300).length,
+      status_3xx: allStatusCodes.filter((s) => s >= 300 && s < 400).length,
+      status_4xx: allStatusCodes.filter((s) => s >= 400 && s < 500).length,
+      status_5xx: allStatusCodes.filter((s) => s >= 500).length,
+      p50_ms: percentile(allDurations, 50),
+      p95_ms: percentile(allDurations, 95),
+      p99_ms: percentile(allDurations, 99),
+      slowest_routes: routeStats.sort((a, b) => b.p95_ms - a.p95_ms).slice(0, 10)
+    };
+    this.routes = /* @__PURE__ */ new Map();
+    this.windowStart = /* @__PURE__ */ new Date();
+    return result;
+  }
+  get totalRequests() {
+    let total = 0;
+    for (const data of Array.from(this.routes.values())) {
+      total += data.durations.length;
+    }
+    return total;
+  }
+  // Replace dynamic path segments with placeholders to avoid
+  // high-cardinality route keys in the database.
+  // /users/123         → /users/[id]
+  // /posts/abc-def-123 → /posts/[id]
+  // /api/v1/orders/99  → /api/v1/orders/[id]
+  normalizeRoute(path) {
+    return path.replace(
+      /\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi,
+      "/[id]"
+    ).replace(/\/\d+/g, "/[id]").replace(/\/[a-zA-Z0-9]{20,}/g, "/[id]");
+  }
+};
+
+// src/client.ts
+var SDK_VERSION = "1.0.0";
+var SECRET_PATTERNS = [
+  /sk_live_[a-zA-Z0-9_]+/g,
+  /sk_test_[a-zA-Z0-9_]+/g,
+  /pk_live_[a-zA-Z0-9_]+/g,
+  /pk_test_[a-zA-Z0-9_]+/g,
+  /rely_live_[a-zA-Z0-9_]+/g,
+  /rely_test_[a-zA-Z0-9_]+/g,
+  /Bearer\s+[a-zA-Z0-9._\-]+/g,
+  /password\s*[=:]\s*["']?[^\s"',}\]]{4,}/gi,
+  /secret\s*[=:]\s*["']?[^\s"',}\]]{4,}/gi,
+  /api[_\-]?key\s*[=:]\s*["']?[^\s"',}\]]{4,}/gi,
+  /token\s*[=:]\s*["']?[^\s"',}\]]{4,}/gi,
+  /AKIA[A-Z0-9]{16}/g,
+  /[a-z0-9]{32,}:[a-z0-9]{32,}/g
+  // generic key:secret format
+];
+var MIN_FLUSH_INTERVAL = 1e4;
+var DEFAULT_FLUSH_INTERVAL = 6e4;
+var INGEST_TIMEOUT_MS = 1e4;
+var MAX_ERROR_MESSAGE_LENGTH = 2e3;
+var MAX_STACK_TRACE_LENGTH = 1e4;
+var MAX_METRIC_NAME_LENGTH = 100;
+var MAX_HEALTH_CHECK_NAME_LENGTH = 100;
+var RelyClient = class {
+  constructor(options) {
+    if (!options.apiKey || typeof options.apiKey !== "string") {
+      throw new Error(
+        "[Rely] apiKey is required. Get your API key at rely.net/settings/api-keys"
+      );
+    }
+    if (!options.apiKey.startsWith("rely_")) {
+      console.warn(
+        "[Rely] Warning: API key format looks incorrect. Keys should start with rely_live_ or rely_test_"
+      );
+    }
+    this.apiKey = options.apiKey;
+    this.baseUrl = (options.baseUrl ?? "https://rely.net").replace(/\/$/, "");
+    this.environment = options.environment ?? process.env.NODE_ENV ?? "production";
+    this.flushInterval = Math.max(
+      MIN_FLUSH_INTERVAL,
+      options.flushInterval ?? DEFAULT_FLUSH_INTERVAL
+    );
+    this.sanitizeErrors = options.sanitizeErrors ?? true;
+    this.debug = options.debug ?? false;
+    this.healthChecks = /* @__PURE__ */ new Map();
+    this.pendingMetrics = [];
+    this.requestBuffer = new RequestBuffer();
+    this.flushTimer = null;
+    this.deploymentSent = false;
+    this.isDestroyed = false;
+    this.log(`SDK initialized`);
+    this.log(`Environment: ${this.environment}`);
+    this.log(`Flush interval: ${this.flushInterval / 1e3}s`);
+    this.log(`Base URL: ${this.baseUrl}`);
+    this.initialize();
+  }
+  // Register a health check function.
+  // The function should throw if the check fails.
+  // Returns `this` for chaining.
+  healthCheck(name, fn) {
+    if (this.isDestroyed) {
+      this.log("Warning: SDK has been destroyed, ignoring healthCheck()");
+      return this;
+    }
+    const trimmedName = name?.trim();
+    if (!trimmedName) {
+      throw new Error("[Rely] Health check name must be a non-empty string");
+    }
+    if (trimmedName.length > MAX_HEALTH_CHECK_NAME_LENGTH) {
+      throw new Error(
+        `[Rely] Health check name must be under ${MAX_HEALTH_CHECK_NAME_LENGTH} characters`
+      );
+    }
+    if (typeof fn !== "function") {
+      throw new Error(
+        "[Rely] Health check must be a function that returns a Promise"
+      );
+    }
+    this.healthChecks.set(trimmedName, fn);
+    this.log(`Registered health check: "${trimmedName}"`);
+    return this;
+  }
+  // Send a custom metric value.
+  // Returns `this` for chaining.
+  metric(name, value, tags) {
+    if (this.isDestroyed) return this;
+    if (typeof value !== "number" || !isFinite(value)) {
+      this.log(`Warning: invalid metric value for "${name}": ${value}`);
+      return this;
+    }
+    const trimmedName = name?.trim();
+    if (!trimmedName || trimmedName.length > MAX_METRIC_NAME_LENGTH) {
+      this.log(`Warning: invalid metric name: "${name}"`);
+      return this;
+    }
+    this.pendingMetrics.push({
+      name: trimmedName,
+      value,
+      tags: tags ? this.sanitizeTags(tags) : void 0
+    });
+    return this;
+  }
+  // Manually send a deployment marker.
+  // Called automatically on initialization in production.
+  // Use this to send additional metadata with your deployment.
+  deployment(info) {
+    if (this.isDestroyed) return;
+    this.sendDeploymentMarker(info);
+  }
+  // Called by withRelyMiddleware on each HTTP request.
+  // Not intended to be called directly in most cases.
+  recordRequest(route, statusCode, durationMs) {
+    if (this.isDestroyed) return;
+    this.requestBuffer.record(route, statusCode, durationMs);
+  }
+  // Manually trigger a flush of all pending data.
+  // The SDK flushes automatically on the flush interval.
+  // Use this for graceful shutdown scenarios.
+  async flush() {
+    if (this.isDestroyed) return;
+    const payload = {
+      version: SDK_VERSION,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (this.healthChecks.size > 0) {
+      payload.health_checks = await this.runHealthChecks();
+    }
+    if (this.pendingMetrics.length > 0) {
+      payload.metrics = [...this.pendingMetrics];
+      this.pendingMetrics = [];
+    }
+    payload.runtime = this.collectRuntimeStats();
+    if (this.requestBuffer.totalRequests > 0) {
+      payload.request_telemetry = this.requestBuffer.flush();
+    }
+    await this.sendPayload(payload);
+  }
+  // Destroy the client and stop all background activity.
+  // Call this during graceful shutdown if needed.
+  destroy() {
+    if (this.isDestroyed) return;
+    this.isDestroyed = true;
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    this.log("SDK destroyed");
+  }
+  initialize() {
+    if (this.environment === "production" || this.environment === "staging") {
+      this.sendDeploymentMarker();
+    }
+    this.flushTimer = setInterval(() => {
+      this.flush().catch((err) => {
+        this.log(`Flush error: ${err instanceof Error ? err.message : err}`);
+      });
+    }, this.flushInterval);
+    if (typeof this.flushTimer === "object" && this.flushTimer !== null) {
+      const timer = this.flushTimer;
+      if (typeof timer.unref === "function") {
+        timer.unref();
+      }
+    }
+  }
+  async runHealthChecks() {
+    const results = await Promise.allSettled(
+      Array.from(this.healthChecks.entries()).map(
+        async ([name, fn]) => {
+          const start = Date.now();
+          try {
+            await fn();
+            const duration = Date.now() - start;
+            this.log(`\u2713 Health check "${name}" passed (${duration}ms)`);
+            return {
+              name,
+              status: "passing",
+              duration_ms: duration
+            };
+          } catch (err) {
+            const duration = Date.now() - start;
+            const error = err instanceof Error ? err : new Error(String(err));
+            this.log(`\u2717 Health check "${name}" failed: ${error.message}`);
+            return {
+              name,
+              status: "failing",
+              duration_ms: duration,
+              error_message: this.sanitizeErrors ? this.sanitize(
+                error.message.slice(0, MAX_ERROR_MESSAGE_LENGTH)
+              ) : error.message.slice(0, MAX_ERROR_MESSAGE_LENGTH),
+              stack_trace: error.stack ? this.sanitizeErrors ? this.sanitize(
+                error.stack.slice(0, MAX_STACK_TRACE_LENGTH)
+              ) : error.stack.slice(0, MAX_STACK_TRACE_LENGTH) : void 0
+            };
+          }
+        }
+      )
+    );
+    return results.filter(
+      (r) => r.status === "fulfilled"
+    ).map((r) => r.value);
+  }
+  collectRuntimeStats() {
+    const mem = process.memoryUsage();
+    return {
+      memory_heap_used_mb: Math.round(mem.heapUsed / 1024 / 1024 * 100) / 100,
+      memory_heap_total_mb: Math.round(mem.heapTotal / 1024 / 1024 * 100) / 100,
+      memory_rss_mb: Math.round(mem.rss / 1024 / 1024 * 100) / 100,
+      cpu_usage_percent: 0,
+      process_uptime_secs: Math.floor(process.uptime()),
+      node_version: process.version,
+      region: process.env.VERCEL_REGION ?? process.env.AWS_REGION ?? process.env.FLY_REGION ?? process.env.RAILWAY_REGION ?? "unknown"
+    };
+  }
+  sendDeploymentMarker(info) {
+    if (this.deploymentSent && !info) return;
+    this.deploymentSent = true;
+    const payload = {
+      version: SDK_VERSION,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      deployment: {
+        version: info?.version ?? process.env.VERCEL_GIT_COMMIT_SHA ?? process.env.RAILWAY_GIT_COMMIT_SHA ?? process.env.FLY_APP_VERSION ?? process.env.RENDER_GIT_COMMIT ?? "unknown",
+        environment: info?.environment ?? this.environment,
+        branch: info?.branch ?? process.env.VERCEL_GIT_COMMIT_REF ?? process.env.RAILWAY_GIT_BRANCH ?? process.env.RENDER_GIT_BRANCH ?? "unknown",
+        commit_message: info?.commit_message ?? process.env.VERCEL_GIT_COMMIT_MESSAGE ?? "",
+        framework: "next.js",
+        framework_version: this.detectFrameworkVersion(),
+        node_version: process.version,
+        region: process.env.VERCEL_REGION ?? "unknown",
+        deployment_url: process.env.VERCEL_URL ? `https://${process.env.VERCEL_URL}` : "",
+        metadata: info?.metadata ?? {}
+      }
+    };
+    this.sendPayload(payload).catch(() => {
+    });
+  }
+  async sendPayload(payload) {
+    try {
+      this.log(`Sending payload (${JSON.stringify(payload).length} bytes)`);
+      const response = await fetch(`${this.baseUrl}/api/sdk/ingest`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`,
+          "User-Agent": `@rely-net/sdk/${SDK_VERSION}`
+        },
+        body: JSON.stringify(payload),
+        signal: AbortSignal.timeout(INGEST_TIMEOUT_MS)
+      });
+      if (this.debug) {
+        if (response.ok) {
+          const body = await response.json();
+          this.log(`Flush successful`);
+          if (body.warnings?.length > 0) {
+            body.warnings.forEach((w) => this.log(`Warning: ${w}`));
+          }
+        } else {
+          this.log(`Ingest returned HTTP ${response.status}`);
+        }
+      }
+    } catch (err) {
+      this.log(
+        `Send failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  sanitize(str) {
+    let result = str;
+    for (const pattern of SECRET_PATTERNS) {
+      pattern.lastIndex = 0;
+      result = result.replace(pattern, "[REDACTED]");
+    }
+    return result;
+  }
+  sanitizeTags(tags) {
+    const sanitized = {};
+    for (const [key, value] of Object.entries(tags)) {
+      sanitized[key] = this.sanitize(String(value).slice(0, 200));
+    }
+    return sanitized;
+  }
+  detectFrameworkVersion() {
+    try {
+      const pkg = require("next/package.json");
+      return pkg.version;
+    } catch {
+      return "unknown";
+    }
+  }
+  log(message) {
+    if (this.debug) {
+      console.log(`[Rely] ${message}`);
+    }
+  }
+};
+
+// src/middleware.ts
+function withRelyMiddleware(rely, middleware) {
+  return async (request, event) => {
+    const start = Date.now();
+    const url = new URL(request.url);
+    let response;
+    if (middleware) {
+      response = await middleware(request, event);
+    } else {
+      const { NextResponse } = await import("next/server");
+      response = NextResponse.next();
+    }
+    const duration = Date.now() - start;
+    const status = response?.status ?? 200;
+    const path = url.pathname;
+    if (!path.startsWith("/_next/") && !path.startsWith("/favicon") && !path.startsWith("/robots") && !path.startsWith("/sitemap")) {
+      rely.recordRequest(path, status, duration);
+    }
+    return response;
+  };
+}
+
+// src/types.ts
+var SDK_VERSION2 = "1.0.0";
+
+// src/index.ts
+var _instance = null;
+function createRelyClient(options) {
+  _instance = new RelyClient(options);
+  return _instance;
+}
+function getRelyClient() {
+  if (!_instance) {
+    throw new Error(
+      "[Rely] SDK not initialized.\nCall createRelyClient() in your instrumentation.ts file first.\nSee https://rely.net/docs/sdk for setup instructions."
+    );
+  }
+  return _instance;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Rely,
+  RelyClient,
+  SDK_VERSION,
+  createRelyClient,
+  getRelyClient,
+  withRelyMiddleware
+});

package/dist/index.mjs

@@ -0,0 +1,422 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/collectors/requests.ts
+function percentile(arr, p) {
+  if (arr.length === 0) return 0;
+  const sorted = [...arr].sort((a, b) => a - b);
+  const index = Math.ceil(p / 100 * sorted.length) - 1;
+  return sorted[Math.max(0, index)];
+}
+var RequestBuffer = class {
+  constructor() {
+    this.routes = /* @__PURE__ */ new Map();
+    this.windowStart = /* @__PURE__ */ new Date();
+  }
+  record(route, statusCode, durationMs) {
+    const normalized = this.normalizeRoute(route);
+    if (!this.routes.has(normalized)) {
+      this.routes.set(normalized, { durations: [], statusCodes: [] });
+    }
+    const r = this.routes.get(normalized);
+    r.durations.push(Math.max(0, durationMs));
+    r.statusCodes.push(statusCode);
+  }
+  flush() {
+    const allDurations = [];
+    const allStatusCodes = [];
+    const routeStats = [];
+    for (const [route, data] of Array.from(this.routes.entries())) {
+      allDurations.push(...data.durations);
+      allStatusCodes.push(...data.statusCodes);
+      routeStats.push({
+        route,
+        p95_ms: percentile(data.durations, 95),
+        count: data.durations.length
+      });
+    }
+    const result = {
+      window_start: this.windowStart.toISOString(),
+      window_end: (/* @__PURE__ */ new Date()).toISOString(),
+      total_requests: allDurations.length,
+      status_2xx: allStatusCodes.filter((s) => s >= 200 && s < 300).length,
+      status_3xx: allStatusCodes.filter((s) => s >= 300 && s < 400).length,
+      status_4xx: allStatusCodes.filter((s) => s >= 400 && s < 500).length,
+      status_5xx: allStatusCodes.filter((s) => s >= 500).length,
+      p50_ms: percentile(allDurations, 50),
+      p95_ms: percentile(allDurations, 95),
+      p99_ms: percentile(allDurations, 99),
+      slowest_routes: routeStats.sort((a, b) => b.p95_ms - a.p95_ms).slice(0, 10)
+    };
+    this.routes = /* @__PURE__ */ new Map();
+    this.windowStart = /* @__PURE__ */ new Date();
+    return result;
+  }
+  get totalRequests() {
+    let total = 0;
+    for (const data of Array.from(this.routes.values())) {
+      total += data.durations.length;
+    }
+    return total;
+  }
+  // Replace dynamic path segments with placeholders to avoid
+  // high-cardinality route keys in the database.
+  // /users/123         → /users/[id]
+  // /posts/abc-def-123 → /posts/[id]
+  // /api/v1/orders/99  → /api/v1/orders/[id]
+  normalizeRoute(path) {
+    return path.replace(
+      /\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi,
+      "/[id]"
+    ).replace(/\/\d+/g, "/[id]").replace(/\/[a-zA-Z0-9]{20,}/g, "/[id]");
+  }
+};
+
+// src/client.ts
+var SDK_VERSION = "1.0.0";
+var SECRET_PATTERNS = [
+  /sk_live_[a-zA-Z0-9_]+/g,
+  /sk_test_[a-zA-Z0-9_]+/g,
+  /pk_live_[a-zA-Z0-9_]+/g,
+  /pk_test_[a-zA-Z0-9_]+/g,
+  /rely_live_[a-zA-Z0-9_]+/g,
+  /rely_test_[a-zA-Z0-9_]+/g,
+  /Bearer\s+[a-zA-Z0-9._\-]+/g,
+  /password\s*[=:]\s*["']?[^\s"',}\]]{4,}/gi,
+  /secret\s*[=:]\s*["']?[^\s"',}\]]{4,}/gi,
+  /api[_\-]?key\s*[=:]\s*["']?[^\s"',}\]]{4,}/gi,
+  /token\s*[=:]\s*["']?[^\s"',}\]]{4,}/gi,
+  /AKIA[A-Z0-9]{16}/g,
+  /[a-z0-9]{32,}:[a-z0-9]{32,}/g
+  // generic key:secret format
+];
+var MIN_FLUSH_INTERVAL = 1e4;
+var DEFAULT_FLUSH_INTERVAL = 6e4;
+var INGEST_TIMEOUT_MS = 1e4;
+var MAX_ERROR_MESSAGE_LENGTH = 2e3;
+var MAX_STACK_TRACE_LENGTH = 1e4;
+var MAX_METRIC_NAME_LENGTH = 100;
+var MAX_HEALTH_CHECK_NAME_LENGTH = 100;
+var RelyClient = class {
+  constructor(options) {
+    if (!options.apiKey || typeof options.apiKey !== "string") {
+      throw new Error(
+        "[Rely] apiKey is required. Get your API key at rely.net/settings/api-keys"
+      );
+    }
+    if (!options.apiKey.startsWith("rely_")) {
+      console.warn(
+        "[Rely] Warning: API key format looks incorrect. Keys should start with rely_live_ or rely_test_"
+      );
+    }
+    this.apiKey = options.apiKey;
+    this.baseUrl = (options.baseUrl ?? "https://rely.net").replace(/\/$/, "");
+    this.environment = options.environment ?? process.env.NODE_ENV ?? "production";
+    this.flushInterval = Math.max(
+      MIN_FLUSH_INTERVAL,
+      options.flushInterval ?? DEFAULT_FLUSH_INTERVAL
+    );
+    this.sanitizeErrors = options.sanitizeErrors ?? true;
+    this.debug = options.debug ?? false;
+    this.healthChecks = /* @__PURE__ */ new Map();
+    this.pendingMetrics = [];
+    this.requestBuffer = new RequestBuffer();
+    this.flushTimer = null;
+    this.deploymentSent = false;
+    this.isDestroyed = false;
+    this.log(`SDK initialized`);
+    this.log(`Environment: ${this.environment}`);
+    this.log(`Flush interval: ${this.flushInterval / 1e3}s`);
+    this.log(`Base URL: ${this.baseUrl}`);
+    this.initialize();
+  }
+  // Register a health check function.
+  // The function should throw if the check fails.
+  // Returns `this` for chaining.
+  healthCheck(name, fn) {
+    if (this.isDestroyed) {
+      this.log("Warning: SDK has been destroyed, ignoring healthCheck()");
+      return this;
+    }
+    const trimmedName = name?.trim();
+    if (!trimmedName) {
+      throw new Error("[Rely] Health check name must be a non-empty string");
+    }
+    if (trimmedName.length > MAX_HEALTH_CHECK_NAME_LENGTH) {
+      throw new Error(
+        `[Rely] Health check name must be under ${MAX_HEALTH_CHECK_NAME_LENGTH} characters`
+      );
+    }
+    if (typeof fn !== "function") {
+      throw new Error(
+        "[Rely] Health check must be a function that returns a Promise"
+      );
+    }
+    this.healthChecks.set(trimmedName, fn);
+    this.log(`Registered health check: "${trimmedName}"`);
+    return this;
+  }
+  // Send a custom metric value.
+  // Returns `this` for chaining.
+  metric(name, value, tags) {
+    if (this.isDestroyed) return this;
+    if (typeof value !== "number" || !isFinite(value)) {
+      this.log(`Warning: invalid metric value for "${name}": ${value}`);
+      return this;
+    }
+    const trimmedName = name?.trim();
+    if (!trimmedName || trimmedName.length > MAX_METRIC_NAME_LENGTH) {
+      this.log(`Warning: invalid metric name: "${name}"`);
+      return this;
+    }
+    this.pendingMetrics.push({
+      name: trimmedName,
+      value,
+      tags: tags ? this.sanitizeTags(tags) : void 0
+    });
+    return this;
+  }
+  // Manually send a deployment marker.
+  // Called automatically on initialization in production.
+  // Use this to send additional metadata with your deployment.
+  deployment(info) {
+    if (this.isDestroyed) return;
+    this.sendDeploymentMarker(info);
+  }
+  // Called by withRelyMiddleware on each HTTP request.
+  // Not intended to be called directly in most cases.
+  recordRequest(route, statusCode, durationMs) {
+    if (this.isDestroyed) return;
+    this.requestBuffer.record(route, statusCode, durationMs);
+  }
+  // Manually trigger a flush of all pending data.
+  // The SDK flushes automatically on the flush interval.
+  // Use this for graceful shutdown scenarios.
+  async flush() {
+    if (this.isDestroyed) return;
+    const payload = {
+      version: SDK_VERSION,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (this.healthChecks.size > 0) {
+      payload.health_checks = await this.runHealthChecks();
+    }
+    if (this.pendingMetrics.length > 0) {
+      payload.metrics = [...this.pendingMetrics];
+      this.pendingMetrics = [];
+    }
+    payload.runtime = this.collectRuntimeStats();
+    if (this.requestBuffer.totalRequests > 0) {
+      payload.request_telemetry = this.requestBuffer.flush();
+    }
+    await this.sendPayload(payload);
+  }
+  // Destroy the client and stop all background activity.
+  // Call this during graceful shutdown if needed.
+  destroy() {
+    if (this.isDestroyed) return;
+    this.isDestroyed = true;
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    this.log("SDK destroyed");
+  }
+  initialize() {
+    if (this.environment === "production" || this.environment === "staging") {
+      this.sendDeploymentMarker();
+    }
+    this.flushTimer = setInterval(() => {
+      this.flush().catch((err) => {
+        this.log(`Flush error: ${err instanceof Error ? err.message : err}`);
+      });
+    }, this.flushInterval);
+    if (typeof this.flushTimer === "object" && this.flushTimer !== null) {
+      const timer = this.flushTimer;
+      if (typeof timer.unref === "function") {
+        timer.unref();
+      }
+    }
+  }
+  async runHealthChecks() {
+    const results = await Promise.allSettled(
+      Array.from(this.healthChecks.entries()).map(
+        async ([name, fn]) => {
+          const start = Date.now();
+          try {
+            await fn();
+            const duration = Date.now() - start;
+            this.log(`\u2713 Health check "${name}" passed (${duration}ms)`);
+            return {
+              name,
+              status: "passing",
+              duration_ms: duration
+            };
+          } catch (err) {
+            const duration = Date.now() - start;
+            const error = err instanceof Error ? err : new Error(String(err));
+            this.log(`\u2717 Health check "${name}" failed: ${error.message}`);
+            return {
+              name,
+              status: "failing",
+              duration_ms: duration,
+              error_message: this.sanitizeErrors ? this.sanitize(
+                error.message.slice(0, MAX_ERROR_MESSAGE_LENGTH)
+              ) : error.message.slice(0, MAX_ERROR_MESSAGE_LENGTH),
+              stack_trace: error.stack ? this.sanitizeErrors ? this.sanitize(
+                error.stack.slice(0, MAX_STACK_TRACE_LENGTH)
+              ) : error.stack.slice(0, MAX_STACK_TRACE_LENGTH) : void 0
+            };
+          }
+        }
+      )
+    );
+    return results.filter(
+      (r) => r.status === "fulfilled"
+    ).map((r) => r.value);
+  }
+  collectRuntimeStats() {
+    const mem = process.memoryUsage();
+    return {
+      memory_heap_used_mb: Math.round(mem.heapUsed / 1024 / 1024 * 100) / 100,
+      memory_heap_total_mb: Math.round(mem.heapTotal / 1024 / 1024 * 100) / 100,
+      memory_rss_mb: Math.round(mem.rss / 1024 / 1024 * 100) / 100,
+      cpu_usage_percent: 0,
+      process_uptime_secs: Math.floor(process.uptime()),
+      node_version: process.version,
+      region: process.env.VERCEL_REGION ?? process.env.AWS_REGION ?? process.env.FLY_REGION ?? process.env.RAILWAY_REGION ?? "unknown"
+    };
+  }
+  sendDeploymentMarker(info) {
+    if (this.deploymentSent && !info) return;
+    this.deploymentSent = true;
+    const payload = {
+      version: SDK_VERSION,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      deployment: {
+        version: info?.version ?? process.env.VERCEL_GIT_COMMIT_SHA ?? process.env.RAILWAY_GIT_COMMIT_SHA ?? process.env.FLY_APP_VERSION ?? process.env.RENDER_GIT_COMMIT ?? "unknown",
+        environment: info?.environment ?? this.environment,
+        branch: info?.branch ?? process.env.VERCEL_GIT_COMMIT_REF ?? process.env.RAILWAY_GIT_BRANCH ?? process.env.RENDER_GIT_BRANCH ?? "unknown",
+        commit_message: info?.commit_message ?? process.env.VERCEL_GIT_COMMIT_MESSAGE ?? "",
+        framework: "next.js",
+        framework_version: this.detectFrameworkVersion(),
+        node_version: process.version,
+        region: process.env.VERCEL_REGION ?? "unknown",
+        deployment_url: process.env.VERCEL_URL ? `https://${process.env.VERCEL_URL}` : "",
+        metadata: info?.metadata ?? {}
+      }
+    };
+    this.sendPayload(payload).catch(() => {
+    });
+  }
+  async sendPayload(payload) {
+    try {
+      this.log(`Sending payload (${JSON.stringify(payload).length} bytes)`);
+      const response = await fetch(`${this.baseUrl}/api/sdk/ingest`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`,
+          "User-Agent": `@rely-net/sdk/${SDK_VERSION}`
+        },
+        body: JSON.stringify(payload),
+        signal: AbortSignal.timeout(INGEST_TIMEOUT_MS)
+      });
+      if (this.debug) {
+        if (response.ok) {
+          const body = await response.json();
+          this.log(`Flush successful`);
+          if (body.warnings?.length > 0) {
+            body.warnings.forEach((w) => this.log(`Warning: ${w}`));
+          }
+        } else {
+          this.log(`Ingest returned HTTP ${response.status}`);
+        }
+      }
+    } catch (err) {
+      this.log(
+        `Send failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  sanitize(str) {
+    let result = str;
+    for (const pattern of SECRET_PATTERNS) {
+      pattern.lastIndex = 0;
+      result = result.replace(pattern, "[REDACTED]");
+    }
+    return result;
+  }
+  sanitizeTags(tags) {
+    const sanitized = {};
+    for (const [key, value] of Object.entries(tags)) {
+      sanitized[key] = this.sanitize(String(value).slice(0, 200));
+    }
+    return sanitized;
+  }
+  detectFrameworkVersion() {
+    try {
+      const pkg = __require("next/package.json");
+      return pkg.version;
+    } catch {
+      return "unknown";
+    }
+  }
+  log(message) {
+    if (this.debug) {
+      console.log(`[Rely] ${message}`);
+    }
+  }
+};
+
+// src/middleware.ts
+function withRelyMiddleware(rely, middleware) {
+  return async (request, event) => {
+    const start = Date.now();
+    const url = new URL(request.url);
+    let response;
+    if (middleware) {
+      response = await middleware(request, event);
+    } else {
+      const { NextResponse } = await import("next/server");
+      response = NextResponse.next();
+    }
+    const duration = Date.now() - start;
+    const status = response?.status ?? 200;
+    const path = url.pathname;
+    if (!path.startsWith("/_next/") && !path.startsWith("/favicon") && !path.startsWith("/robots") && !path.startsWith("/sitemap")) {
+      rely.recordRequest(path, status, duration);
+    }
+    return response;
+  };
+}
+
+// src/types.ts
+var SDK_VERSION2 = "1.0.0";
+
+// src/index.ts
+var _instance = null;
+function createRelyClient(options) {
+  _instance = new RelyClient(options);
+  return _instance;
+}
+function getRelyClient() {
+  if (!_instance) {
+    throw new Error(
+      "[Rely] SDK not initialized.\nCall createRelyClient() in your instrumentation.ts file first.\nSee https://rely.net/docs/sdk for setup instructions."
+    );
+  }
+  return _instance;
+}
+export {
+  RelyClient as Rely,
+  RelyClient,
+  SDK_VERSION2 as SDK_VERSION,
+  createRelyClient,
+  getRelyClient,
+  withRelyMiddleware
+};

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@rely-net/sdk",
+  "version": "1.0.0",
+  "description": "Official SDK for rely.net — monitor your app from the inside",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "monitoring",
+    "observability",
+    "health-checks",
+    "rely",
+    "uptime",
+    "apm",
+    "status-page",
+    "nextjs"
+  ],
+  "author": "Rely <hello@rely.net>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rely-net/sdk"
+  },
+  "homepage": "https://rely.net/docs/sdk",
+  "bugs": {
+    "url": "https://github.com/rely-net/sdk/issues"
+  },
+  "peerDependencies": {
+    "next": ">=13.0.0"
+  },
+  "peerDependenciesMeta": {
+    "next": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0",
+    "@types/node": "^20.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}