@openstatus/health-disk 0.1.4-dev.0

package/README.md

@@ -0,0 +1,70 @@
+# @openstatus/health-disk
+
+Disk space probe for [`@openstatus/health`](https://jsr.io/@openstatus/health).
+Reads the free space of the filesystem holding `path` and fails the check
+when it drops below a threshold — the input a readiness probe needs on
+anything that writes to local disk: SQLite, uploads, logs, a build cache.
+
+```sh
+deno add jsr:@openstatus/health jsr:@openstatus/health-disk
+npm install @openstatus/health @openstatus/health-disk
+```
+
+```ts
+import { createHealthHandler } from "@openstatus/health";
+import { diskProbe } from "@openstatus/health-disk";
+
+Deno.serve(
+  createHealthHandler({
+    probes: [diskProbe({ path: "/data", minFreePercent: 10 })],
+  }),
+);
+```
+
+`path` can be any file or directory; the probe reports on the filesystem
+that holds it, so `/data` and `/data/app.db` answer the same. Free space is
+what an unprivileged process can still use (`bavail`), which is what your
+writes see once root's reserved blocks are excluded. The check fails below
+`minFreePercent` (10% by default) or below `minFreeBytes` when that is set
+instead; pass both to enforce both. A threshold failure throws
+`DiskSpaceError`, which carries the `usage`; a `statfs` error or an
+unreadable result fails the check with that error instead.
+
+```ts
+diskProbe({
+  path: "/var/lib/app",
+  minFreeBytes: 2 * 1024 ** 3,
+  // optional overrides from the Probe contract
+  name: "data-volume",
+  critical: true,
+  timeoutMs: 500,
+  skip: () => env.DATA_DIR == null,
+});
+```
+
+Non-critical by default: a disk filling up degrades the report early enough
+to act on before writes start failing. Set `critical: true` when the
+instance should stop taking traffic instead — a database volume, for
+instance.
+
+This probe uses `fs.promises.statfs` from `node:fs`, so it runs on Node.js,
+Deno and Bun but not on edge runtimes. `statfs` is 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,66 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const node_fs_promises = require_rolldown_runtime.__toESM(require("node:fs/promises"));
+const __openstatus_health = require_rolldown_runtime.__toESM(require("@openstatus/health"));
+
+//#region src/mod.ts
+/** Probe name when `name` is unset. */
+const diskDefaultName = "disk";
+/** Path when `path` is unset. */
+const diskDefaultPath = ".";
+/** Threshold when neither `minFreePercent` nor `minFreeBytes` is set. */
+const diskDefaultMinFreePercent = 10;
+/** Thrown by the probe when free space is below the threshold. */
+var DiskSpaceError = class extends Error {
+	/** The usage that crossed the threshold. */
+	usage;
+	/** Build the error for `usage` against the threshold described by `reason`. */
+	constructor(usage, reason) {
+		super(reason);
+		this.name = "DiskSpaceError";
+		this.usage = usage;
+	}
+};
+/** A probe that fails when free space is below `minFreePercent` or `minFreeBytes`; non-critical by default. Throws `ProbeConfigError` for an empty `path` or a negative threshold. */
+function diskProbe(options = {}) {
+	const path = options.path ?? diskDefaultPath;
+	if (typeof path !== "string" || path.length === 0) throw new __openstatus_health.ProbeConfigError("diskProbe", "path", typeof path !== "string" ? `must be a string, got ${String(path)}` : "must not be empty");
+	const minFreeBytes = options.minFreeBytes;
+	const minFreePercent = options.minFreePercent ?? (minFreeBytes == null ? diskDefaultMinFreePercent : void 0);
+	for (const [field, value] of [["minFreePercent", minFreePercent], ["minFreeBytes", minFreeBytes]]) if (value != null && (!Number.isFinite(value) || value < 0)) throw new __openstatus_health.ProbeConfigError("diskProbe", field, `must be a non-negative number, got ${String(value)}`);
+	const statfs = options.statfs ?? node_fs_promises.statfs;
+	return {
+		name: options.name ?? diskDefaultName,
+		critical: options.critical ?? false,
+		timeoutMs: options.timeoutMs,
+		skip: options.skip,
+		run: async () => {
+			const stats = await statfs(path);
+			const usage = toUsage(stats);
+			if (minFreeBytes != null && usage.freeBytes < minFreeBytes) throw new DiskSpaceError(usage, `${usage.freeBytes} bytes free, fewer than ${minFreeBytes}`);
+			if (minFreePercent != null && usage.freeBytes / usage.totalBytes * 100 < minFreePercent) throw new DiskSpaceError(usage, `${usage.freePercent}% free, less than ${minFreePercent}%`);
+			return usage;
+		}
+	};
+}
+function toUsage(stats) {
+	const { bsize, blocks, bavail } = stats;
+	if (![
+		bsize,
+		blocks,
+		bavail
+	].every((n) => Number.isFinite(n) && n >= 0) || bsize === 0 || blocks === 0) throw new Error("unexpected statfs result");
+	const totalBytes = blocks * bsize;
+	const freeBytes = bavail * bsize;
+	return {
+		freeBytes,
+		totalBytes,
+		freePercent: Math.round(freeBytes / totalBytes * 1e3) / 10
+	};
+}
+
+//#endregion
+exports.DiskSpaceError = DiskSpaceError;
+exports.diskDefaultMinFreePercent = diskDefaultMinFreePercent;
+exports.diskDefaultName = diskDefaultName;
+exports.diskDefaultPath = diskDefaultPath;
+exports.diskProbe = diskProbe;

package/dist/mod.d.cts

@@ -0,0 +1,54 @@
+import { Probe, ProbeOverrides } from "@openstatus/health";
+
+//#region src/mod.d.ts
+
+/** Probe name when `name` is unset. */
+declare const diskDefaultName = "disk";
+/** Path when `path` is unset. */
+declare const diskDefaultPath = ".";
+/** Threshold when neither `minFreePercent` nor `minFreeBytes` is set. */
+declare const diskDefaultMinFreePercent = 10;
+/** The subset of `fs.StatsFs` the probe reads. */
+interface DiskStats {
+  /** Block size in bytes. */
+  readonly bsize: number;
+  /** Total blocks. */
+  readonly blocks: number;
+  /** Blocks available to unprivileged users. */
+  readonly bavail: number;
+}
+/** What the probe reads the filesystem with; `fs.promises.statfs` by default. */
+type DiskStatfs = (path: string) => PromiseLike<DiskStats>;
+/** Options for `diskProbe()`. */
+interface DiskProbeOptions extends ProbeOverrides {
+  /** Any path on the filesystem to check. Default `diskDefaultPath`. */
+  readonly path?: string;
+  /** Fail when free space drops below this percentage of the total. Default `diskDefaultMinFreePercent` unless `minFreeBytes` is set. */
+  readonly minFreePercent?: number;
+  /** Fail when fewer bytes than this are free. */
+  readonly minFreeBytes?: number;
+  /** Replacement `statfs`, for tests. */
+  readonly statfs?: DiskStatfs;
+}
+/** What a healthy check resolves with. */
+interface DiskUsage {
+  /** Bytes available. */
+  readonly freeBytes: number;
+  /** Bytes in total. */
+  readonly totalBytes: number;
+  /** `freeBytes` as a percentage of `totalBytes`, rounded to one decimal. */
+  readonly freePercent: number;
+}
+/** Thrown by the probe when free space is below the threshold. */
+declare class DiskSpaceError extends Error {
+  /** The usage that crossed the threshold. */
+  readonly usage: DiskUsage;
+  /** Build the error for `usage` against the threshold described by `reason`. */
+  constructor(usage: DiskUsage, reason: string);
+}
+/** A probe that fails when free space is below `minFreePercent` or `minFreeBytes`; non-critical by default. Throws `ProbeConfigError` for an empty `path` or a negative threshold. */
+declare function diskProbe(options?: DiskProbeOptions): Probe;
+//# sourceMappingURL=mod.d.ts.map
+//#endregion
+export { DiskProbeOptions, DiskSpaceError, DiskStatfs, DiskStats, DiskUsage, diskDefaultMinFreePercent, diskDefaultName, diskDefaultPath, diskProbe };
+//# 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":";;;;;AA2CwD,cApB3C,eAAA,GAoB2C,MAAA;AAYxD;AAUa,cAxCA,eAAA,GAwCe,GAAA;;AAEV,cAxCL,yBAAA,GAwCK,EAAA;;AAFkB,UAnCnB,SAAA,CAmCmB;EAAK;EAazB,SAAA,KAAS,EAAA,MAAA;EAAA;EAAA,SAAU,MAAA,EAAA,MAAA;EAAqB;EAAQ,SAAA,MAAA,EAAA,MAAA;;;KAtCpD,UAAA,qBAA+B,YAAY;;UAGtC,gBAAA,SAAyB;;;;;;;;oBAQtB;;;UAIH,SAAA;;;;;;;;;cAUJ,cAAA,SAAuB,KAAA;;kBAElB;;qBAGG;;;iBAQL,SAAA,WAAmB,mBAAwB"}

package/dist/mod.d.ts

@@ -0,0 +1,54 @@
+import { Probe, ProbeOverrides } from "@openstatus/health";
+
+//#region src/mod.d.ts
+
+/** Probe name when `name` is unset. */
+declare const diskDefaultName = "disk";
+/** Path when `path` is unset. */
+declare const diskDefaultPath = ".";
+/** Threshold when neither `minFreePercent` nor `minFreeBytes` is set. */
+declare const diskDefaultMinFreePercent = 10;
+/** The subset of `fs.StatsFs` the probe reads. */
+interface DiskStats {
+  /** Block size in bytes. */
+  readonly bsize: number;
+  /** Total blocks. */
+  readonly blocks: number;
+  /** Blocks available to unprivileged users. */
+  readonly bavail: number;
+}
+/** What the probe reads the filesystem with; `fs.promises.statfs` by default. */
+type DiskStatfs = (path: string) => PromiseLike<DiskStats>;
+/** Options for `diskProbe()`. */
+interface DiskProbeOptions extends ProbeOverrides {
+  /** Any path on the filesystem to check. Default `diskDefaultPath`. */
+  readonly path?: string;
+  /** Fail when free space drops below this percentage of the total. Default `diskDefaultMinFreePercent` unless `minFreeBytes` is set. */
+  readonly minFreePercent?: number;
+  /** Fail when fewer bytes than this are free. */
+  readonly minFreeBytes?: number;
+  /** Replacement `statfs`, for tests. */
+  readonly statfs?: DiskStatfs;
+}
+/** What a healthy check resolves with. */
+interface DiskUsage {
+  /** Bytes available. */
+  readonly freeBytes: number;
+  /** Bytes in total. */
+  readonly totalBytes: number;
+  /** `freeBytes` as a percentage of `totalBytes`, rounded to one decimal. */
+  readonly freePercent: number;
+}
+/** Thrown by the probe when free space is below the threshold. */
+declare class DiskSpaceError extends Error {
+  /** The usage that crossed the threshold. */
+  readonly usage: DiskUsage;
+  /** Build the error for `usage` against the threshold described by `reason`. */
+  constructor(usage: DiskUsage, reason: string);
+}
+/** A probe that fails when free space is below `minFreePercent` or `minFreeBytes`; non-critical by default. Throws `ProbeConfigError` for an empty `path` or a negative threshold. */
+declare function diskProbe(options?: DiskProbeOptions): Probe;
+//# sourceMappingURL=mod.d.ts.map
+//#endregion
+export { DiskProbeOptions, DiskSpaceError, DiskStatfs, DiskStats, DiskUsage, diskDefaultMinFreePercent, diskDefaultName, diskDefaultPath, diskProbe };
+//# 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":";;;;;AA2CwD,cApB3C,eAAA,GAoB2C,MAAA;AAYxD;AAUa,cAxCA,eAAA,GAwCe,GAAA;;AAEV,cAxCL,yBAAA,GAwCK,EAAA;;AAFkB,UAnCnB,SAAA,CAmCmB;EAAK;EAazB,SAAA,KAAS,EAAA,MAAA;EAAA;EAAA,SAAU,MAAA,EAAA,MAAA;EAAqB;EAAQ,SAAA,MAAA,EAAA,MAAA;;;KAtCpD,UAAA,qBAA+B,YAAY;;UAGtC,gBAAA,SAAyB;;;;;;;;oBAQtB;;;UAIH,SAAA;;;;;;;;;cAUJ,cAAA,SAAuB,KAAA;;kBAElB;;qBAGG;;;iBAQL,SAAA,WAAmB,mBAAwB"}

package/dist/mod.js

@@ -0,0 +1,62 @@
+import { statfs } from "node:fs/promises";
+import { ProbeConfigError } from "@openstatus/health";
+
+//#region src/mod.ts
+/** Probe name when `name` is unset. */
+const diskDefaultName = "disk";
+/** Path when `path` is unset. */
+const diskDefaultPath = ".";
+/** Threshold when neither `minFreePercent` nor `minFreeBytes` is set. */
+const diskDefaultMinFreePercent = 10;
+/** Thrown by the probe when free space is below the threshold. */
+var DiskSpaceError = class extends Error {
+	/** The usage that crossed the threshold. */
+	usage;
+	/** Build the error for `usage` against the threshold described by `reason`. */
+	constructor(usage, reason) {
+		super(reason);
+		this.name = "DiskSpaceError";
+		this.usage = usage;
+	}
+};
+/** A probe that fails when free space is below `minFreePercent` or `minFreeBytes`; non-critical by default. Throws `ProbeConfigError` for an empty `path` or a negative threshold. */
+function diskProbe(options = {}) {
+	const path = options.path ?? diskDefaultPath;
+	if (typeof path !== "string" || path.length === 0) throw new ProbeConfigError("diskProbe", "path", typeof path !== "string" ? `must be a string, got ${String(path)}` : "must not be empty");
+	const minFreeBytes = options.minFreeBytes;
+	const minFreePercent = options.minFreePercent ?? (minFreeBytes == null ? diskDefaultMinFreePercent : void 0);
+	for (const [field, value] of [["minFreePercent", minFreePercent], ["minFreeBytes", minFreeBytes]]) if (value != null && (!Number.isFinite(value) || value < 0)) throw new ProbeConfigError("diskProbe", field, `must be a non-negative number, got ${String(value)}`);
+	const statfs$1 = options.statfs ?? statfs;
+	return {
+		name: options.name ?? diskDefaultName,
+		critical: options.critical ?? false,
+		timeoutMs: options.timeoutMs,
+		skip: options.skip,
+		run: async () => {
+			const stats = await statfs$1(path);
+			const usage = toUsage(stats);
+			if (minFreeBytes != null && usage.freeBytes < minFreeBytes) throw new DiskSpaceError(usage, `${usage.freeBytes} bytes free, fewer than ${minFreeBytes}`);
+			if (minFreePercent != null && usage.freeBytes / usage.totalBytes * 100 < minFreePercent) throw new DiskSpaceError(usage, `${usage.freePercent}% free, less than ${minFreePercent}%`);
+			return usage;
+		}
+	};
+}
+function toUsage(stats) {
+	const { bsize, blocks, bavail } = stats;
+	if (![
+		bsize,
+		blocks,
+		bavail
+	].every((n) => Number.isFinite(n) && n >= 0) || bsize === 0 || blocks === 0) throw new Error("unexpected statfs result");
+	const totalBytes = blocks * bsize;
+	const freeBytes = bavail * bsize;
+	return {
+		freeBytes,
+		totalBytes,
+		freePercent: Math.round(freeBytes / totalBytes * 1e3) / 10
+	};
+}
+
+//#endregion
+export { DiskSpaceError, diskDefaultMinFreePercent, diskDefaultName, diskDefaultPath, diskProbe };
+//# sourceMappingURL=mod.js.map

package/dist/mod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.js","names":["usage: DiskUsage","reason: string","options: DiskProbeOptions","statfs","fsStatfs","stats: DiskStats"],"sources":["../src/mod.ts"],"sourcesContent":["/**\n * Disk space probe for `@openstatus/health`: reads the free space of the\n * filesystem holding `path` and fails below a threshold.\n *\n * ```ts\n * import { diskProbe } from \"@openstatus/health-disk\";\n *\n * const probe = diskProbe({ path: \"/data\", minFreePercent: 10 });\n * ```\n *\n * Node.js, Deno and Bun only: it uses `node:fs`.\n *\n * @module\n */\n\nimport { statfs as fsStatfs } from \"node:fs/promises\";\nimport {\n  type Probe,\n  ProbeConfigError,\n  type ProbeOverrides,\n} from \"@openstatus/health\";\n\n/** Probe name when `name` is unset. */\nexport const diskDefaultName = \"disk\";\n/** Path when `path` is unset. */\nexport const diskDefaultPath = \".\";\n/** Threshold when neither `minFreePercent` nor `minFreeBytes` is set. */\nexport const diskDefaultMinFreePercent = 10;\n\n/** The subset of `fs.StatsFs` the probe reads. */\nexport interface DiskStats {\n  /** Block size in bytes. */\n  readonly bsize: number;\n  /** Total blocks. */\n  readonly blocks: number;\n  /** Blocks available to unprivileged users. */\n  readonly bavail: number;\n}\n\n/** What the probe reads the filesystem with; `fs.promises.statfs` by default. */\nexport type DiskStatfs = (path: string) => PromiseLike<DiskStats>;\n\n/** Options for `diskProbe()`. */\nexport interface DiskProbeOptions extends ProbeOverrides {\n  /** Any path on the filesystem to check. Default `diskDefaultPath`. */\n  readonly path?: string;\n  /** Fail when free space drops below this percentage of the total. Default `diskDefaultMinFreePercent` unless `minFreeBytes` is set. */\n  readonly minFreePercent?: number;\n  /** Fail when fewer bytes than this are free. */\n  readonly minFreeBytes?: number;\n  /** Replacement `statfs`, for tests. */\n  readonly statfs?: DiskStatfs;\n}\n\n/** What a healthy check resolves with. */\nexport interface DiskUsage {\n  /** Bytes available. */\n  readonly freeBytes: number;\n  /** Bytes in total. */\n  readonly totalBytes: number;\n  /** `freeBytes` as a percentage of `totalBytes`, rounded to one decimal. */\n  readonly freePercent: number;\n}\n\n/** Thrown by the probe when free space is below the threshold. */\nexport class DiskSpaceError extends Error {\n  /** The usage that crossed the threshold. */\n  readonly usage: DiskUsage;\n\n  /** Build the error for `usage` against the threshold described by `reason`. */\n  constructor(usage: DiskUsage, reason: string) {\n    super(reason);\n    this.name = \"DiskSpaceError\";\n    this.usage = usage;\n  }\n}\n\n/** A probe that fails when free space is below `minFreePercent` or `minFreeBytes`; non-critical by default. Throws `ProbeConfigError` for an empty `path` or a negative threshold. */\nexport function diskProbe(options: DiskProbeOptions = {}): Probe {\n  const path = options.path ?? diskDefaultPath;\n  if (typeof path !== \"string\" || path.length === 0) {\n    throw new ProbeConfigError(\n      \"diskProbe\",\n      \"path\",\n      typeof path !== \"string\"\n        ? `must be a string, got ${String(path)}`\n        : \"must not be empty\",\n    );\n  }\n  const minFreeBytes = options.minFreeBytes;\n  const minFreePercent = options.minFreePercent ??\n    (minFreeBytes == null ? diskDefaultMinFreePercent : undefined);\n  for (\n    const [field, value] of [\n      [\"minFreePercent\", minFreePercent],\n      [\"minFreeBytes\", minFreeBytes],\n    ] as const\n  ) {\n    if (value != null && (!Number.isFinite(value) || value < 0)) {\n      throw new ProbeConfigError(\n        \"diskProbe\",\n        field,\n        `must be a non-negative number, got ${String(value)}`,\n      );\n    }\n  }\n  const statfs = options.statfs ?? fsStatfs;\n  return {\n    name: options.name ?? diskDefaultName,\n    critical: options.critical ?? false,\n    timeoutMs: options.timeoutMs,\n    skip: options.skip,\n    run: async () => {\n      const stats = await statfs(path);\n      const usage = toUsage(stats);\n      if (minFreeBytes != null && usage.freeBytes < minFreeBytes) {\n        throw new DiskSpaceError(\n          usage,\n          `${usage.freeBytes} bytes free, fewer than ${minFreeBytes}`,\n        );\n      }\n      if (\n        minFreePercent != null &&\n        (usage.freeBytes / usage.totalBytes) * 100 < minFreePercent\n      ) {\n        throw new DiskSpaceError(\n          usage,\n          `${usage.freePercent}% free, less than ${minFreePercent}%`,\n        );\n      }\n      return usage;\n    },\n  };\n}\n\nfunction toUsage(stats: DiskStats): DiskUsage {\n  const { bsize, blocks, bavail } = stats;\n  if (\n    ![bsize, blocks, bavail].every((n) => Number.isFinite(n) && n >= 0) ||\n    bsize === 0 || blocks === 0\n  ) {\n    throw new Error(\"unexpected statfs result\");\n  }\n  const totalBytes = blocks * bsize;\n  const freeBytes = bavail * bsize;\n  return {\n    freeBytes,\n    totalBytes,\n    freePercent: Math.round((freeBytes / totalBytes) * 1000) / 10,\n  };\n}\n"],"mappings":";;;;;AAuBA,MAAa,kBAAkB;;AAE/B,MAAa,kBAAkB;;AAE/B,MAAa,4BAA4B;;AAsCzC,IAAa,iBAAb,cAAoC,MAAM;;CAExC,AAAS;;CAGT,YAAYA,OAAkBC,QAAgB;AAC5C,QAAM,OAAO;AACb,OAAK,OAAO;AACZ,OAAK,QAAQ;CACd;AACF;;AAGD,SAAgB,UAAUC,UAA4B,CAAE,GAAS;CAC/D,MAAM,OAAO,QAAQ,QAAQ;AAC7B,YAAW,SAAS,YAAY,KAAK,WAAW,EAC9C,OAAM,IAAI,iBACR,aACA,eACO,SAAS,YACX,wBAAwB,OAAO,KAAK,CAAC,IACtC;CAGR,MAAM,eAAe,QAAQ;CAC7B,MAAM,iBAAiB,QAAQ,mBAC5B,gBAAgB,OAAO;AAC1B,MACE,MAAM,CAAC,OAAO,MAAM,IAAI,CACtB,CAAC,kBAAkB,cAAe,GAClC,CAAC,gBAAgB,YAAa,CAC/B,EAED,KAAI,SAAS,UAAU,OAAO,SAAS,MAAM,IAAI,QAAQ,GACvD,OAAM,IAAI,iBACR,aACA,QACC,qCAAqC,OAAO,MAAM,CAAC;CAI1D,MAAMC,WAAS,QAAQ,UAAUC;AACjC,QAAO;EACL,MAAM,QAAQ,QAAQ;EACtB,UAAU,QAAQ,YAAY;EAC9B,WAAW,QAAQ;EACnB,MAAM,QAAQ;EACd,KAAK,YAAY;GACf,MAAM,QAAQ,MAAM,SAAO,KAAK;GAChC,MAAM,QAAQ,QAAQ,MAAM;AAC5B,OAAI,gBAAgB,QAAQ,MAAM,YAAY,aAC5C,OAAM,IAAI,eACR,QACC,EAAE,MAAM,UAAU,0BAA0B,aAAa;AAG9D,OACE,kBAAkB,QACjB,MAAM,YAAY,MAAM,aAAc,MAAM,eAE7C,OAAM,IAAI,eACR,QACC,EAAE,MAAM,YAAY,oBAAoB,eAAe;AAG5D,UAAO;EACR;CACF;AACF;AAED,SAAS,QAAQC,OAA6B;CAC5C,MAAM,EAAE,OAAO,QAAQ,QAAQ,GAAG;AAClC,MACG;EAAC;EAAO;EAAQ;CAAO,EAAC,MAAM,CAAC,MAAM,OAAO,SAAS,EAAE,IAAI,KAAK,EAAE,IACnE,UAAU,KAAK,WAAW,EAE1B,OAAM,IAAI,MAAM;CAElB,MAAM,aAAa,SAAS;CAC5B,MAAM,YAAY,SAAS;AAC3B,QAAO;EACL;EACA;EACA,aAAa,KAAK,MAAO,YAAY,aAAc,IAAK,GAAG;CAC5D;AACF"}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@openstatus/health-disk",
+  "version": "0.1.4-dev.0",
+  "description": "Disk space probe for @openstatus/health",
+  "keywords": [
+    "openstatus",
+    "health",
+    "healthcheck",
+    "disk",
+    "storage",
+    "filesystem",
+    "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/disk/"
+  },
+  "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"
+  }
+}