@openstatus/health-memory 0.1.4-dev.0

package/README.md

@@ -0,0 +1,73 @@
+# @openstatus/health-memory
+
+Memory probe for [`@openstatus/health`](https://jsr.io/@openstatus/health).
+Compares the process's heap in use with the V8 heap limit — and its
+resident set size with a byte budget — and fails the check above either
+threshold, so a leak turns the report `degraded` before the process is
+killed for running out of memory.
+
+```sh
+deno add jsr:@openstatus/health jsr:@openstatus/health-memory
+npm install @openstatus/health @openstatus/health-memory
+```
+
+```ts
+import { createHealthHandler } from "@openstatus/health";
+import { memoryProbe } from "@openstatus/health-memory";
+
+Deno.serve(
+  createHealthHandler({
+    probes: [memoryProbe({ maxHeapUsedPercent: 90 })],
+  }),
+);
+```
+
+The heap percentage is `heapUsed` from `process.memoryUsage()` over
+`heap_size_limit` from `v8.getHeapStatistics()` — the limit V8 will
+actually grow to, which honours `--max-old-space-size`. It is the number
+that predicts an out-of-memory crash. `maxRssBytes` bounds the whole
+resident set instead, which is what a container limit or an OOM killer
+measures; set it a little under that limit. The check fails above
+`maxHeapUsedPercent` (90% by default) or above `maxRssBytes` when that is
+set instead; pass both to enforce both. A failing check throws
+`MemoryPressureError`, which carries the `reading`, and a healthy one
+reports `heapUsedBytes`, `heapLimitBytes`, `heapUsedPercent` and `rssBytes`.
+
+```ts
+memoryProbe({
+  maxHeapUsedPercent: 85,
+  maxRssBytes: 900 * 1024 * 1024,
+  // optional overrides from the Probe contract
+  name: "heap",
+  critical: true,
+  timeoutMs: 100,
+  skip: () => env.NODE_ENV !== "production",
+});
+```
+
+Non-critical by default: memory pressure is an alert to act on, and taking
+a leaking instance out of rotation only shifts its traffic onto the others.
+Set `critical: true` when your platform restarts unhealthy instances and
+that is the recovery you want.
+
+This probe uses `node:process` and `node:v8`, so it runs on Node.js, Deno
+and Bun but not on edge runtimes. Both readers are typed structurally and
+can be replaced for tests.
+
+## About openstatus
+
+[openstatus](https://www.openstatus.dev/) is the open-source uptime monitoring
+and status page platform. This package is part of
+[`@openstatus/health`](https://github.com/openstatusHQ/health), the `/health`
+endpoints behind openstatus's own services, extracted so any JavaScript server
+can expose one. Point an
+[openstatus monitor](https://www.openstatus.dev/docs/reference/http-monitor)
+at the endpoint and assert on `status` in the body to be alerted on
+`degraded` before it becomes `unhealthy`.
+
+Source: [github.com/openstatusHQ/health](https://github.com/openstatusHQ/health).
+Issues and PRs welcome.
+
+## License
+
+[MIT](https://github.com/openstatusHQ/health/blob/main/LICENSE)

package/dist/_virtual/rolldown_runtime.cjs

@@ -0,0 +1,30 @@
+//#region rolldown:runtime
+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 __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});

package/dist/mod.cjs

@@ -0,0 +1,63 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const node_process = require_rolldown_runtime.__toESM(require("node:process"));
+const node_v8 = require_rolldown_runtime.__toESM(require("node:v8"));
+const __openstatus_health = require_rolldown_runtime.__toESM(require("@openstatus/health"));
+
+//#region src/mod.ts
+/** Probe name when `name` is unset. */
+const memoryDefaultName = "memory";
+/** Threshold when neither `maxHeapUsedPercent` nor `maxRssBytes` is set. */
+const memoryDefaultMaxHeapUsedPercent = 90;
+/** Thrown by the probe when usage is above a threshold. */
+var MemoryPressureError = class extends Error {
+	/** The reading that crossed the threshold. */
+	reading;
+	/** Build the error for `reading` against the threshold described by `reason`. */
+	constructor(reading, reason) {
+		super(reason);
+		this.name = "MemoryPressureError";
+		this.reading = reading;
+	}
+};
+/** A probe that fails above `maxHeapUsedPercent` or `maxRssBytes`; non-critical by default. Throws `ProbeConfigError` for a negative or non-finite threshold. */
+function memoryProbe(options = {}) {
+	const maxRssBytes = options.maxRssBytes;
+	const maxHeapUsedPercent = options.maxHeapUsedPercent ?? (maxRssBytes == null ? memoryDefaultMaxHeapUsedPercent : void 0);
+	for (const [field, value] of [["maxHeapUsedPercent", maxHeapUsedPercent], ["maxRssBytes", maxRssBytes]]) if (value != null && (!Number.isFinite(value) || value < 0)) throw new __openstatus_health.ProbeConfigError("memoryProbe", field, `must be a non-negative number, got ${String(value)}`);
+	const memoryUsage = options.memoryUsage ?? (() => node_process.default.memoryUsage());
+	const heapStatistics = options.heapStatistics ?? node_v8.getHeapStatistics;
+	return {
+		name: options.name ?? memoryDefaultName,
+		critical: options.critical ?? false,
+		timeoutMs: options.timeoutMs,
+		skip: options.skip,
+		run: () => {
+			const reading = read(memoryUsage(), heapStatistics());
+			if (maxRssBytes != null && reading.rssBytes > maxRssBytes) throw new MemoryPressureError(reading, `rss ${reading.rssBytes} bytes exceeds ${maxRssBytes}`);
+			if (maxHeapUsedPercent != null && reading.heapUsedBytes / reading.heapLimitBytes * 100 > maxHeapUsedPercent) throw new MemoryPressureError(reading, `heap ${reading.heapUsedPercent}% used exceeds ${maxHeapUsedPercent}%`);
+			return reading;
+		}
+	};
+}
+function read(usage, heap) {
+	const heapUsedBytes = usage.heapUsed;
+	const heapLimitBytes = heap.heap_size_limit;
+	const rssBytes = usage.rss;
+	if (![
+		heapUsedBytes,
+		heapLimitBytes,
+		rssBytes
+	].every((n) => Number.isFinite(n) && n >= 0) || heapLimitBytes === 0) throw new Error("unexpected memory statistics");
+	return {
+		heapUsedBytes,
+		heapLimitBytes,
+		heapUsedPercent: Math.round(heapUsedBytes / heapLimitBytes * 1e3) / 10,
+		rssBytes
+	};
+}
+
+//#endregion
+exports.MemoryPressureError = MemoryPressureError;
+exports.memoryDefaultMaxHeapUsedPercent = memoryDefaultMaxHeapUsedPercent;
+exports.memoryDefaultName = memoryDefaultName;
+exports.memoryProbe = memoryProbe;

package/dist/mod.d.cts

@@ -0,0 +1,55 @@
+import { Probe, ProbeOverrides } from "@openstatus/health";
+
+//#region src/mod.d.ts
+
+/** Probe name when `name` is unset. */
+declare const memoryDefaultName = "memory";
+/** Threshold when neither `maxHeapUsedPercent` nor `maxRssBytes` is set. */
+declare const memoryDefaultMaxHeapUsedPercent = 90;
+/** The subset of `process.memoryUsage()` the probe reads. */
+interface MemoryUsageSample {
+  /** Bytes of V8 heap in use. */
+  readonly heapUsed: number;
+  /** Resident set size in bytes. */
+  readonly rss: number;
+}
+/** The subset of `v8.getHeapStatistics()` the probe reads. */
+interface HeapStatisticsSample {
+  /** The maximum heap size V8 will grow to. */
+  readonly heap_size_limit: number;
+}
+/** Options for `memoryProbe()`. */
+interface MemoryProbeOptions extends ProbeOverrides {
+  /** Fail when the heap in use exceeds this percentage of the heap limit. Default `memoryDefaultMaxHeapUsedPercent` unless `maxRssBytes` is set. */
+  readonly maxHeapUsedPercent?: number;
+  /** Fail when the resident set size exceeds this many bytes. */
+  readonly maxRssBytes?: number;
+  /** Replacement `process.memoryUsage`, for tests. */
+  readonly memoryUsage?: () => MemoryUsageSample;
+  /** Replacement `v8.getHeapStatistics`, for tests. */
+  readonly heapStatistics?: () => HeapStatisticsSample;
+}
+/** What a healthy check resolves with. */
+interface MemoryReading {
+  /** Bytes of heap in use. */
+  readonly heapUsedBytes: number;
+  /** The heap limit in bytes. */
+  readonly heapLimitBytes: number;
+  /** `heapUsedBytes` as a percentage of `heapLimitBytes`, rounded to one decimal. */
+  readonly heapUsedPercent: number;
+  /** Resident set size in bytes. */
+  readonly rssBytes: number;
+}
+/** Thrown by the probe when usage is above a threshold. */
+declare class MemoryPressureError extends Error {
+  /** The reading that crossed the threshold. */
+  readonly reading: MemoryReading;
+  /** Build the error for `reading` against the threshold described by `reason`. */
+  constructor(reading: MemoryReading, reason: string);
+}
+/** A probe that fails above `maxHeapUsedPercent` or `maxRssBytes`; non-critical by default. Throws `ProbeConfigError` for a negative or non-finite threshold. */
+declare function memoryProbe(options?: MemoryProbeOptions): Probe;
+//# sourceMappingURL=mod.d.ts.map
+//#endregion
+export { HeapStatisticsSample, MemoryPressureError, MemoryProbeOptions, MemoryReading, MemoryUsageSample, memoryDefaultMaxHeapUsedPercent, memoryDefaultName, memoryProbe };
+//# sourceMappingURL=mod.d.cts.map

package/dist/mod.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.cts","names":[],"sources":["../src/mod.ts"],"sourcesContent":[],"mappings":";;;;;AAyEuB,cAhDV,iBAAA,GAgDU,QAAA;;AALuB,cAzCjC,+BAAA,GAyCiC,EAAA;AAa9C;AAA2B,UAnDV,iBAAA,CAmDU;EAAA;EAAiC,SAAG,QAAA,EAAA,MAAA;EAAK;;;;UA3CnD,oBAAA;;;;;UAMA,kBAAA,SAA2B;;;;;;+BAMb;;kCAEG;;;UAIjB,aAAA;;;;;;;;;;;cAYJ,mBAAA,SAA4B,KAAA;;oBAErB;;uBAGG;;;iBAQP,WAAA,WAAqB,qBAA0B"}

package/dist/mod.d.ts

@@ -0,0 +1,55 @@
+import { Probe, ProbeOverrides } from "@openstatus/health";
+
+//#region src/mod.d.ts
+
+/** Probe name when `name` is unset. */
+declare const memoryDefaultName = "memory";
+/** Threshold when neither `maxHeapUsedPercent` nor `maxRssBytes` is set. */
+declare const memoryDefaultMaxHeapUsedPercent = 90;
+/** The subset of `process.memoryUsage()` the probe reads. */
+interface MemoryUsageSample {
+  /** Bytes of V8 heap in use. */
+  readonly heapUsed: number;
+  /** Resident set size in bytes. */
+  readonly rss: number;
+}
+/** The subset of `v8.getHeapStatistics()` the probe reads. */
+interface HeapStatisticsSample {
+  /** The maximum heap size V8 will grow to. */
+  readonly heap_size_limit: number;
+}
+/** Options for `memoryProbe()`. */
+interface MemoryProbeOptions extends ProbeOverrides {
+  /** Fail when the heap in use exceeds this percentage of the heap limit. Default `memoryDefaultMaxHeapUsedPercent` unless `maxRssBytes` is set. */
+  readonly maxHeapUsedPercent?: number;
+  /** Fail when the resident set size exceeds this many bytes. */
+  readonly maxRssBytes?: number;
+  /** Replacement `process.memoryUsage`, for tests. */
+  readonly memoryUsage?: () => MemoryUsageSample;
+  /** Replacement `v8.getHeapStatistics`, for tests. */
+  readonly heapStatistics?: () => HeapStatisticsSample;
+}
+/** What a healthy check resolves with. */
+interface MemoryReading {
+  /** Bytes of heap in use. */
+  readonly heapUsedBytes: number;
+  /** The heap limit in bytes. */
+  readonly heapLimitBytes: number;
+  /** `heapUsedBytes` as a percentage of `heapLimitBytes`, rounded to one decimal. */
+  readonly heapUsedPercent: number;
+  /** Resident set size in bytes. */
+  readonly rssBytes: number;
+}
+/** Thrown by the probe when usage is above a threshold. */
+declare class MemoryPressureError extends Error {
+  /** The reading that crossed the threshold. */
+  readonly reading: MemoryReading;
+  /** Build the error for `reading` against the threshold described by `reason`. */
+  constructor(reading: MemoryReading, reason: string);
+}
+/** A probe that fails above `maxHeapUsedPercent` or `maxRssBytes`; non-critical by default. Throws `ProbeConfigError` for a negative or non-finite threshold. */
+declare function memoryProbe(options?: MemoryProbeOptions): Probe;
+//# sourceMappingURL=mod.d.ts.map
+//#endregion
+export { HeapStatisticsSample, MemoryPressureError, MemoryProbeOptions, MemoryReading, MemoryUsageSample, memoryDefaultMaxHeapUsedPercent, memoryDefaultName, memoryProbe };
+//# sourceMappingURL=mod.d.ts.map

package/dist/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","names":[],"sources":["../src/mod.ts"],"sourcesContent":[],"mappings":";;;;;AAyEuB,cAhDV,iBAAA,GAgDU,QAAA;;AALuB,cAzCjC,+BAAA,GAyCiC,EAAA;AAa9C;AAA2B,UAnDV,iBAAA,CAmDU;EAAA;EAAiC,SAAG,QAAA,EAAA,MAAA;EAAK;;;;UA3CnD,oBAAA;;;;;UAMA,kBAAA,SAA2B;;;;;;+BAMb;;kCAEG;;;UAIjB,aAAA;;;;;;;;;;;cAYJ,mBAAA,SAA4B,KAAA;;oBAErB;;uBAGG;;;iBAQP,WAAA,WAAqB,qBAA0B"}

package/dist/mod.js

@@ -0,0 +1,60 @@
+import process from "node:process";
+import { getHeapStatistics } from "node:v8";
+import { ProbeConfigError } from "@openstatus/health";
+
+//#region src/mod.ts
+/** Probe name when `name` is unset. */
+const memoryDefaultName = "memory";
+/** Threshold when neither `maxHeapUsedPercent` nor `maxRssBytes` is set. */
+const memoryDefaultMaxHeapUsedPercent = 90;
+/** Thrown by the probe when usage is above a threshold. */
+var MemoryPressureError = class extends Error {
+	/** The reading that crossed the threshold. */
+	reading;
+	/** Build the error for `reading` against the threshold described by `reason`. */
+	constructor(reading, reason) {
+		super(reason);
+		this.name = "MemoryPressureError";
+		this.reading = reading;
+	}
+};
+/** A probe that fails above `maxHeapUsedPercent` or `maxRssBytes`; non-critical by default. Throws `ProbeConfigError` for a negative or non-finite threshold. */
+function memoryProbe(options = {}) {
+	const maxRssBytes = options.maxRssBytes;
+	const maxHeapUsedPercent = options.maxHeapUsedPercent ?? (maxRssBytes == null ? memoryDefaultMaxHeapUsedPercent : void 0);
+	for (const [field, value] of [["maxHeapUsedPercent", maxHeapUsedPercent], ["maxRssBytes", maxRssBytes]]) if (value != null && (!Number.isFinite(value) || value < 0)) throw new ProbeConfigError("memoryProbe", field, `must be a non-negative number, got ${String(value)}`);
+	const memoryUsage = options.memoryUsage ?? (() => process.memoryUsage());
+	const heapStatistics = options.heapStatistics ?? getHeapStatistics;
+	return {
+		name: options.name ?? memoryDefaultName,
+		critical: options.critical ?? false,
+		timeoutMs: options.timeoutMs,
+		skip: options.skip,
+		run: () => {
+			const reading = read(memoryUsage(), heapStatistics());
+			if (maxRssBytes != null && reading.rssBytes > maxRssBytes) throw new MemoryPressureError(reading, `rss ${reading.rssBytes} bytes exceeds ${maxRssBytes}`);
+			if (maxHeapUsedPercent != null && reading.heapUsedBytes / reading.heapLimitBytes * 100 > maxHeapUsedPercent) throw new MemoryPressureError(reading, `heap ${reading.heapUsedPercent}% used exceeds ${maxHeapUsedPercent}%`);
+			return reading;
+		}
+	};
+}
+function read(usage, heap) {
+	const heapUsedBytes = usage.heapUsed;
+	const heapLimitBytes = heap.heap_size_limit;
+	const rssBytes = usage.rss;
+	if (![
+		heapUsedBytes,
+		heapLimitBytes,
+		rssBytes
+	].every((n) => Number.isFinite(n) && n >= 0) || heapLimitBytes === 0) throw new Error("unexpected memory statistics");
+	return {
+		heapUsedBytes,
+		heapLimitBytes,
+		heapUsedPercent: Math.round(heapUsedBytes / heapLimitBytes * 1e3) / 10,
+		rssBytes
+	};
+}
+
+//#endregion
+export { MemoryPressureError, memoryDefaultMaxHeapUsedPercent, memoryDefaultName, memoryProbe };
+//# sourceMappingURL=mod.js.map

package/dist/mod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.js","names":["reading: MemoryReading","reason: string","options: MemoryProbeOptions","usage: MemoryUsageSample","heap: HeapStatisticsSample"],"sources":["../src/mod.ts"],"sourcesContent":["/**\n * Memory probe for `@openstatus/health`: compares the process's heap usage\n * with the V8 heap limit, and its resident set size with a byte budget,\n * and fails above either threshold.\n *\n * ```ts\n * import { memoryProbe } from \"@openstatus/health-memory\";\n *\n * const probe = memoryProbe({ maxHeapUsedPercent: 90 });\n * ```\n *\n * Node.js, Deno and Bun only: it uses `node:process` and `node:v8`.\n *\n * @module\n */\n\nimport process from \"node:process\";\nimport { getHeapStatistics } from \"node:v8\";\nimport {\n  type Probe,\n  ProbeConfigError,\n  type ProbeOverrides,\n} from \"@openstatus/health\";\n\n/** Probe name when `name` is unset. */\nexport const memoryDefaultName = \"memory\";\n/** Threshold when neither `maxHeapUsedPercent` nor `maxRssBytes` is set. */\nexport const memoryDefaultMaxHeapUsedPercent = 90;\n\n/** The subset of `process.memoryUsage()` the probe reads. */\nexport interface MemoryUsageSample {\n  /** Bytes of V8 heap in use. */\n  readonly heapUsed: number;\n  /** Resident set size in bytes. */\n  readonly rss: number;\n}\n\n/** The subset of `v8.getHeapStatistics()` the probe reads. */\nexport interface HeapStatisticsSample {\n  /** The maximum heap size V8 will grow to. */\n  readonly heap_size_limit: number;\n}\n\n/** Options for `memoryProbe()`. */\nexport interface MemoryProbeOptions extends ProbeOverrides {\n  /** Fail when the heap in use exceeds this percentage of the heap limit. Default `memoryDefaultMaxHeapUsedPercent` unless `maxRssBytes` is set. */\n  readonly maxHeapUsedPercent?: number;\n  /** Fail when the resident set size exceeds this many bytes. */\n  readonly maxRssBytes?: number;\n  /** Replacement `process.memoryUsage`, for tests. */\n  readonly memoryUsage?: () => MemoryUsageSample;\n  /** Replacement `v8.getHeapStatistics`, for tests. */\n  readonly heapStatistics?: () => HeapStatisticsSample;\n}\n\n/** What a healthy check resolves with. */\nexport interface MemoryReading {\n  /** Bytes of heap in use. */\n  readonly heapUsedBytes: number;\n  /** The heap limit in bytes. */\n  readonly heapLimitBytes: number;\n  /** `heapUsedBytes` as a percentage of `heapLimitBytes`, rounded to one decimal. */\n  readonly heapUsedPercent: number;\n  /** Resident set size in bytes. */\n  readonly rssBytes: number;\n}\n\n/** Thrown by the probe when usage is above a threshold. */\nexport class MemoryPressureError extends Error {\n  /** The reading that crossed the threshold. */\n  readonly reading: MemoryReading;\n\n  /** Build the error for `reading` against the threshold described by `reason`. */\n  constructor(reading: MemoryReading, reason: string) {\n    super(reason);\n    this.name = \"MemoryPressureError\";\n    this.reading = reading;\n  }\n}\n\n/** A probe that fails above `maxHeapUsedPercent` or `maxRssBytes`; non-critical by default. Throws `ProbeConfigError` for a negative or non-finite threshold. */\nexport function memoryProbe(options: MemoryProbeOptions = {}): Probe {\n  const maxRssBytes = options.maxRssBytes;\n  const maxHeapUsedPercent = options.maxHeapUsedPercent ??\n    (maxRssBytes == null ? memoryDefaultMaxHeapUsedPercent : undefined);\n  for (\n    const [field, value] of [\n      [\"maxHeapUsedPercent\", maxHeapUsedPercent],\n      [\"maxRssBytes\", maxRssBytes],\n    ] as const\n  ) {\n    if (value != null && (!Number.isFinite(value) || value < 0)) {\n      throw new ProbeConfigError(\n        \"memoryProbe\",\n        field,\n        `must be a non-negative number, got ${String(value)}`,\n      );\n    }\n  }\n  const memoryUsage = options.memoryUsage ?? (() => process.memoryUsage());\n  const heapStatistics = options.heapStatistics ?? getHeapStatistics;\n  return {\n    name: options.name ?? memoryDefaultName,\n    critical: options.critical ?? false,\n    timeoutMs: options.timeoutMs,\n    skip: options.skip,\n    run: () => {\n      const reading = read(memoryUsage(), heapStatistics());\n      if (maxRssBytes != null && reading.rssBytes > maxRssBytes) {\n        throw new MemoryPressureError(\n          reading,\n          `rss ${reading.rssBytes} bytes exceeds ${maxRssBytes}`,\n        );\n      }\n      if (\n        maxHeapUsedPercent != null &&\n        (reading.heapUsedBytes / reading.heapLimitBytes) * 100 >\n          maxHeapUsedPercent\n      ) {\n        throw new MemoryPressureError(\n          reading,\n          `heap ${reading.heapUsedPercent}% used exceeds ${maxHeapUsedPercent}%`,\n        );\n      }\n      return reading;\n    },\n  };\n}\n\nfunction read(\n  usage: MemoryUsageSample,\n  heap: HeapStatisticsSample,\n): MemoryReading {\n  const heapUsedBytes = usage.heapUsed;\n  const heapLimitBytes = heap.heap_size_limit;\n  const rssBytes = usage.rss;\n  if (\n    ![heapUsedBytes, heapLimitBytes, rssBytes].every((n) =>\n      Number.isFinite(n) && n >= 0\n    ) || heapLimitBytes === 0\n  ) {\n    throw new Error(\"unexpected memory statistics\");\n  }\n  return {\n    heapUsedBytes,\n    heapLimitBytes,\n    heapUsedPercent: Math.round((heapUsedBytes / heapLimitBytes) * 1000) / 10,\n    rssBytes,\n  };\n}\n"],"mappings":";;;;;;AAyBA,MAAa,oBAAoB;;AAEjC,MAAa,kCAAkC;;AAyC/C,IAAa,sBAAb,cAAyC,MAAM;;CAE7C,AAAS;;CAGT,YAAYA,SAAwBC,QAAgB;AAClD,QAAM,OAAO;AACb,OAAK,OAAO;AACZ,OAAK,UAAU;CAChB;AACF;;AAGD,SAAgB,YAAYC,UAA8B,CAAE,GAAS;CACnE,MAAM,cAAc,QAAQ;CAC5B,MAAM,qBAAqB,QAAQ,uBAChC,eAAe,OAAO;AACzB,MACE,MAAM,CAAC,OAAO,MAAM,IAAI,CACtB,CAAC,sBAAsB,kBAAmB,GAC1C,CAAC,eAAe,WAAY,CAC7B,EAED,KAAI,SAAS,UAAU,OAAO,SAAS,MAAM,IAAI,QAAQ,GACvD,OAAM,IAAI,iBACR,eACA,QACC,qCAAqC,OAAO,MAAM,CAAC;CAI1D,MAAM,cAAc,QAAQ,gBAAgB,MAAM,QAAQ,aAAa;CACvE,MAAM,iBAAiB,QAAQ,kBAAkB;AACjD,QAAO;EACL,MAAM,QAAQ,QAAQ;EACtB,UAAU,QAAQ,YAAY;EAC9B,WAAW,QAAQ;EACnB,MAAM,QAAQ;EACd,KAAK,MAAM;GACT,MAAM,UAAU,KAAK,aAAa,EAAE,gBAAgB,CAAC;AACrD,OAAI,eAAe,QAAQ,QAAQ,WAAW,YAC5C,OAAM,IAAI,oBACR,UACC,MAAM,QAAQ,SAAS,iBAAiB,YAAY;AAGzD,OACE,sBAAsB,QACrB,QAAQ,gBAAgB,QAAQ,iBAAkB,MACjD,mBAEF,OAAM,IAAI,oBACR,UACC,OAAO,QAAQ,gBAAgB,iBAAiB,mBAAmB;AAGxE,UAAO;EACR;CACF;AACF;AAED,SAAS,KACPC,OACAC,MACe;CACf,MAAM,gBAAgB,MAAM;CAC5B,MAAM,iBAAiB,KAAK;CAC5B,MAAM,WAAW,MAAM;AACvB,MACG;EAAC;EAAe;EAAgB;CAAS,EAAC,MAAM,CAAC,MAChD,OAAO,SAAS,EAAE,IAAI,KAAK,EAC5B,IAAI,mBAAmB,EAExB,OAAM,IAAI,MAAM;AAElB,QAAO;EACL;EACA;EACA,iBAAiB,KAAK,MAAO,gBAAgB,iBAAkB,IAAK,GAAG;EACvE;CACD;AACF"}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@openstatus/health-memory",
+  "version": "0.1.4-dev.0",
+  "description": "Memory pressure probe for @openstatus/health",
+  "keywords": [
+    "openstatus",
+    "health",
+    "healthcheck",
+    "memory",
+    "heap",
+    "rss",
+    "system"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "openstatus",
+    "url": "https://www.openstatus.dev/"
+  },
+  "homepage": "https://github.com/openstatusHQ/health",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/openstatusHQ/health.git",
+    "directory": "packages/memory/"
+  },
+  "bugs": {
+    "url": "https://github.com/openstatusHQ/health/issues"
+  },
+  "type": "module",
+  "module": "./dist/mod.js",
+  "main": "./dist/mod.cjs",
+  "types": "./dist/mod.d.ts",
+  "exports": {
+    ".": {
+      "types": {
+        "import": "./dist/mod.d.ts",
+        "require": "./dist/mod.d.cts"
+      },
+      "import": "./dist/mod.js",
+      "require": "./dist/mod.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist/"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "peerDependencies": {
+    "@openstatus/health": "^0.1.4-dev.0"
+  },
+  "devDependencies": {
+    "@types/node": ">=22",
+    "tsdown": "^0.12.7",
+    "typescript": "^5.8.3"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "prepack": "tsdown",
+    "test": "node --experimental-transform-types --test"
+  }
+}