@bymax-one/nest-core 1.0.0

package/dist/pagination/index.cjs

@@ -0,0 +1,112 @@
+'use strict';
+
+var common = require('@nestjs/common');
+
+// src/pagination/internal.ts
+var DEFAULT_LIMIT = 20;
+var DEFAULT_MAX_LIMIT = 100;
+var MINIMUM = 1;
+function coercePositiveInt(value, fallback) {
+  if (typeof value !== "number" && typeof value !== "string") {
+    return fallback;
+  }
+  const coerced = Number(value);
+  if (!Number.isFinite(coerced) || coerced < MINIMUM) {
+    return fallback;
+  }
+  return Math.floor(coerced);
+}
+function clampLimit(rawLimit, options) {
+  const defaultLimit = coercePositiveInt(options?.defaultLimit, DEFAULT_LIMIT);
+  const maxLimit = coercePositiveInt(options?.maxLimit, DEFAULT_MAX_LIMIT);
+  return Math.min(coercePositiveInt(rawLimit, defaultLimit), maxLimit);
+}
+
+// src/pagination/offset.ts
+function normalizePageQuery(raw, options) {
+  return {
+    page: coercePositiveInt(raw.page, MINIMUM),
+    limit: clampLimit(raw.limit, options)
+  };
+}
+function buildPageResult(items, totalItems, query) {
+  const safePage = coercePositiveInt(query.page, MINIMUM);
+  const safeTotal = Number.isFinite(totalItems) && totalItems > 0 ? Math.floor(totalItems) : 0;
+  const safeLimit = coercePositiveInt(query.limit, DEFAULT_LIMIT);
+  const totalPages = Math.ceil(safeTotal / safeLimit);
+  return {
+    items,
+    meta: { page: safePage, limit: safeLimit, totalItems: safeTotal, totalPages }
+  };
+}
+
+// src/envelope/error-codes.ts
+var BYMAX_VALIDATION_FAILED = "BYMAX_VALIDATION_FAILED";
+
+// src/pagination/cursor.ts
+var BASE64URL_PATTERN = /^[A-Za-z0-9_-]+$/;
+var CURSOR_REJECTION_MESSAGE = "Malformed pagination cursor.";
+function cursorRejection() {
+  return new common.BadRequestException({
+    code: BYMAX_VALIDATION_FAILED,
+    message: CURSOR_REJECTION_MESSAGE
+  });
+}
+function isOrderingKeyRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  return Object.values(value).every(
+    (entry) => typeof entry === "string" || typeof entry === "number" && Number.isFinite(entry)
+  );
+}
+function encodeCursor(payload) {
+  const encodable = Object.values(payload).every(
+    (value) => typeof value === "string" || Number.isFinite(value)
+  );
+  if (!encodable) {
+    throw new Error("encodeCursor payload values must each be a string or a finite number.");
+  }
+  return Buffer.from(JSON.stringify(payload), "utf8").toString("base64url");
+}
+function decodeCursor(cursor) {
+  if (!BASE64URL_PATTERN.test(cursor)) {
+    throw cursorRejection();
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+  } catch {
+    throw cursorRejection();
+  }
+  if (!isOrderingKeyRecord(parsed)) {
+    throw cursorRejection();
+  }
+  return parsed;
+}
+function normalizeCursorQuery(raw, options) {
+  const limit = clampLimit(raw.limit, options);
+  if (typeof raw.cursor === "string") {
+    return { cursor: raw.cursor, limit };
+  }
+  return { limit };
+}
+function buildCursorResult(items, limit, toCursor) {
+  const safeLimit = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 0;
+  if (items.length <= safeLimit) {
+    return { items, nextCursor: null };
+  }
+  const page = items.slice(0, safeLimit);
+  const lastItem = page.at(-1);
+  if (lastItem === void 0) {
+    return { items: page, nextCursor: null };
+  }
+  return { items: page, nextCursor: encodeCursor(toCursor(lastItem)) };
+}
+
+exports.buildCursorResult = buildCursorResult;
+exports.buildPageResult = buildPageResult;
+exports.decodeCursor = decodeCursor;
+exports.encodeCursor = encodeCursor;
+exports.normalizeCursorQuery = normalizeCursorQuery;
+exports.normalizePageQuery = normalizePageQuery;

package/dist/pagination/index.d.cts

@@ -0,0 +1,146 @@
+/** Per-call overrides for the clamping bounds. Never module state. */
+interface PaginationLimitOptions {
+    /** Page size used when the raw limit is absent or invalid. Default `20`. */
+    defaultLimit?: number;
+    /** Hard cap applied to the page size. Default `100`. */
+    maxLimit?: number;
+}
+
+/**
+ * @fileoverview Offset pagination primitives for the `./pagination` subpath.
+ * Pure, framework-neutral helpers that clamp untrusted page/limit input into a
+ * safe {@link PageQuery} and shape a {@link PageResult}. The package never runs
+ * a query: the consumer's repository translates the normalized query into its
+ * own persistence call and passes the rows and total back to the builder.
+ * @layer Utility
+ */
+
+/** A safe, clamped offset query. `page` is 1-based. */
+interface PageQuery {
+    /** 1-based page index, always `>= 1`. */
+    page: number;
+    /** Page size, always within `[1, maxLimit]`. */
+    limit: number;
+}
+/** Pagination metadata describing the position within the full result set. */
+interface PageMeta {
+    /** The 1-based page this result represents. */
+    page: number;
+    /** The page size used to compute the slice. */
+    limit: number;
+    /** Total number of items across all pages. */
+    totalItems: number;
+    /** Total number of pages, `0` when there are no items. */
+    totalPages: number;
+}
+/** A page of items plus its computed {@link PageMeta}. */
+interface PageResult<T> {
+    /** The items on this page. */
+    items: T[];
+    /** Metadata describing this page within the full set. */
+    meta: PageMeta;
+}
+/**
+ * Clamp raw request input into a safe {@link PageQuery}.
+ *
+ * `page` floors to `1`; `limit` floors to `1` and caps at `maxLimit`. Absent,
+ * non-numeric, negative, or zero fields fall back to defaults. Options are
+ * per-call and never retained between calls.
+ *
+ * @param raw - The untrusted page and limit values from the request.
+ * @param options - Per-call `defaultLimit` (default `20`) and `maxLimit`
+ *   (default `100`) overrides.
+ * @returns A clamped, safe query ready to hand to a repository.
+ */
+declare function normalizePageQuery(raw: {
+    page?: unknown;
+    limit?: unknown;
+}, options?: PaginationLimitOptions): PageQuery;
+/**
+ * Assemble a {@link PageResult} from a page of items and the total count.
+ *
+ * `totalPages` is the ceiling of `totalItems` over the query limit; a total of
+ * zero yields zero pages rather than one phantom page. Inputs are defensively
+ * normalized so a misused non-positive limit or a negative/non-finite total
+ * cannot produce an `Infinity`, `NaN`, or negative page count, and `page` is
+ * floored to `1` so the metadata always satisfies the `>= 1` contract.
+ *
+ * @param items - The items on the current page.
+ * @param totalItems - The total number of items across all pages.
+ * @param query - The clamped query that produced this page.
+ * @returns The page of items with its computed metadata.
+ */
+declare function buildPageResult<T>(items: T[], totalItems: number, query: PageQuery): PageResult<T>;
+
+/**
+ * Encode an ordering-key set into an opaque cursor.
+ *
+ * The payload must contain ordering keys only and never sensitive data: cursors
+ * are opaque but neither encrypted nor signed.
+ *
+ * @param payload - The ordering keys to encode.
+ * @returns A url-safe base64 cursor string.
+ * @throws Error when a payload value is not a string or a finite number. This
+ *   covers non-finite numbers (which would encode as `null` and never decode)
+ *   as well as any non-string, non-number value reaching the function through an
+ *   `any`-typed payload.
+ */
+declare function encodeCursor(payload: Record<string, string | number>): string;
+/**
+ * Decode a cursor produced by {@link encodeCursor}.
+ *
+ * Input is untrusted: non-base64url text, non-JSON bytes, wrong JSON shapes, and
+ * disallowed value types all reject with a {@link BYMAX_VALIDATION_FAILED} HTTP
+ * 400 exception. The underlying parse error is never surfaced. The payload must
+ * carry ordering keys only and never sensitive data.
+ *
+ * @param cursor - The opaque cursor string from the request.
+ * @returns The decoded ordering-key payload.
+ * @throws BadRequestException when the cursor is malformed or of the wrong shape.
+ */
+declare function decodeCursor<T extends Record<string, string | number>>(cursor: string): T;
+/** A safe, clamped cursor query. The cursor is validated only at decode time. */
+interface CursorQuery {
+    /** Opaque cursor from a prior page, or absent for the first page. */
+    cursor?: string;
+    /** Page size, always within `[1, maxLimit]`. */
+    limit: number;
+}
+/** A page of items plus the cursor for the next page, if any. */
+interface CursorResult<T> {
+    /** The items on this page, trimmed to the requested limit. */
+    items: T[];
+    /** The cursor for the next page, or `null` when this is the last page. */
+    nextCursor: string | null;
+}
+/**
+ * Clamp raw request input into a safe {@link CursorQuery}.
+ *
+ * The limit is clamped exactly as the offset path clamps it. The cursor is
+ * passed through untouched when it is a string and omitted otherwise; its
+ * contents are validated later by {@link decodeCursor}, not here.
+ *
+ * @param raw - The untrusted cursor and limit values from the request.
+ * @param options - Per-call `defaultLimit` (default `20`) and `maxLimit`
+ *   (default `100`) overrides.
+ * @returns A clamped, safe cursor query.
+ */
+declare function normalizeCursorQuery(raw: {
+    cursor?: unknown;
+    limit?: unknown;
+}, options?: PaginationLimitOptions): CursorQuery;
+/**
+ * Assemble a {@link CursorResult} using the fetch-one-extra convention.
+ *
+ * The repository fetches `limit + 1` rows. A count beyond the limit signals a
+ * further page: the extra row is trimmed and `nextCursor` is derived from the
+ * last returned item. With `limit` rows or fewer, `nextCursor` is `null`.
+ *
+ * @param items - The fetched rows, expected to be up to `limit + 1` long.
+ * @param limit - The requested page size that bounds the returned items.
+ * @param toCursor - Maps the last returned item to its ordering keys.
+ * @returns The trimmed page and the next cursor, or `null` on the last page.
+ */
+declare function buildCursorResult<T>(items: T[], limit: number, toCursor: (lastItem: T) => Record<string, string | number>): CursorResult<T>;
+
+export { type CursorQuery, type CursorResult, type PageMeta, type PageQuery, type PageResult, buildCursorResult, buildPageResult, decodeCursor, encodeCursor, normalizeCursorQuery, normalizePageQuery };

package/dist/pagination/index.d.ts

@@ -0,0 +1,146 @@
+/** Per-call overrides for the clamping bounds. Never module state. */
+interface PaginationLimitOptions {
+    /** Page size used when the raw limit is absent or invalid. Default `20`. */
+    defaultLimit?: number;
+    /** Hard cap applied to the page size. Default `100`. */
+    maxLimit?: number;
+}
+
+/**
+ * @fileoverview Offset pagination primitives for the `./pagination` subpath.
+ * Pure, framework-neutral helpers that clamp untrusted page/limit input into a
+ * safe {@link PageQuery} and shape a {@link PageResult}. The package never runs
+ * a query: the consumer's repository translates the normalized query into its
+ * own persistence call and passes the rows and total back to the builder.
+ * @layer Utility
+ */
+
+/** A safe, clamped offset query. `page` is 1-based. */
+interface PageQuery {
+    /** 1-based page index, always `>= 1`. */
+    page: number;
+    /** Page size, always within `[1, maxLimit]`. */
+    limit: number;
+}
+/** Pagination metadata describing the position within the full result set. */
+interface PageMeta {
+    /** The 1-based page this result represents. */
+    page: number;
+    /** The page size used to compute the slice. */
+    limit: number;
+    /** Total number of items across all pages. */
+    totalItems: number;
+    /** Total number of pages, `0` when there are no items. */
+    totalPages: number;
+}
+/** A page of items plus its computed {@link PageMeta}. */
+interface PageResult<T> {
+    /** The items on this page. */
+    items: T[];
+    /** Metadata describing this page within the full set. */
+    meta: PageMeta;
+}
+/**
+ * Clamp raw request input into a safe {@link PageQuery}.
+ *
+ * `page` floors to `1`; `limit` floors to `1` and caps at `maxLimit`. Absent,
+ * non-numeric, negative, or zero fields fall back to defaults. Options are
+ * per-call and never retained between calls.
+ *
+ * @param raw - The untrusted page and limit values from the request.
+ * @param options - Per-call `defaultLimit` (default `20`) and `maxLimit`
+ *   (default `100`) overrides.
+ * @returns A clamped, safe query ready to hand to a repository.
+ */
+declare function normalizePageQuery(raw: {
+    page?: unknown;
+    limit?: unknown;
+}, options?: PaginationLimitOptions): PageQuery;
+/**
+ * Assemble a {@link PageResult} from a page of items and the total count.
+ *
+ * `totalPages` is the ceiling of `totalItems` over the query limit; a total of
+ * zero yields zero pages rather than one phantom page. Inputs are defensively
+ * normalized so a misused non-positive limit or a negative/non-finite total
+ * cannot produce an `Infinity`, `NaN`, or negative page count, and `page` is
+ * floored to `1` so the metadata always satisfies the `>= 1` contract.
+ *
+ * @param items - The items on the current page.
+ * @param totalItems - The total number of items across all pages.
+ * @param query - The clamped query that produced this page.
+ * @returns The page of items with its computed metadata.
+ */
+declare function buildPageResult<T>(items: T[], totalItems: number, query: PageQuery): PageResult<T>;
+
+/**
+ * Encode an ordering-key set into an opaque cursor.
+ *
+ * The payload must contain ordering keys only and never sensitive data: cursors
+ * are opaque but neither encrypted nor signed.
+ *
+ * @param payload - The ordering keys to encode.
+ * @returns A url-safe base64 cursor string.
+ * @throws Error when a payload value is not a string or a finite number. This
+ *   covers non-finite numbers (which would encode as `null` and never decode)
+ *   as well as any non-string, non-number value reaching the function through an
+ *   `any`-typed payload.
+ */
+declare function encodeCursor(payload: Record<string, string | number>): string;
+/**
+ * Decode a cursor produced by {@link encodeCursor}.
+ *
+ * Input is untrusted: non-base64url text, non-JSON bytes, wrong JSON shapes, and
+ * disallowed value types all reject with a {@link BYMAX_VALIDATION_FAILED} HTTP
+ * 400 exception. The underlying parse error is never surfaced. The payload must
+ * carry ordering keys only and never sensitive data.
+ *
+ * @param cursor - The opaque cursor string from the request.
+ * @returns The decoded ordering-key payload.
+ * @throws BadRequestException when the cursor is malformed or of the wrong shape.
+ */
+declare function decodeCursor<T extends Record<string, string | number>>(cursor: string): T;
+/** A safe, clamped cursor query. The cursor is validated only at decode time. */
+interface CursorQuery {
+    /** Opaque cursor from a prior page, or absent for the first page. */
+    cursor?: string;
+    /** Page size, always within `[1, maxLimit]`. */
+    limit: number;
+}
+/** A page of items plus the cursor for the next page, if any. */
+interface CursorResult<T> {
+    /** The items on this page, trimmed to the requested limit. */
+    items: T[];
+    /** The cursor for the next page, or `null` when this is the last page. */
+    nextCursor: string | null;
+}
+/**
+ * Clamp raw request input into a safe {@link CursorQuery}.
+ *
+ * The limit is clamped exactly as the offset path clamps it. The cursor is
+ * passed through untouched when it is a string and omitted otherwise; its
+ * contents are validated later by {@link decodeCursor}, not here.
+ *
+ * @param raw - The untrusted cursor and limit values from the request.
+ * @param options - Per-call `defaultLimit` (default `20`) and `maxLimit`
+ *   (default `100`) overrides.
+ * @returns A clamped, safe cursor query.
+ */
+declare function normalizeCursorQuery(raw: {
+    cursor?: unknown;
+    limit?: unknown;
+}, options?: PaginationLimitOptions): CursorQuery;
+/**
+ * Assemble a {@link CursorResult} using the fetch-one-extra convention.
+ *
+ * The repository fetches `limit + 1` rows. A count beyond the limit signals a
+ * further page: the extra row is trimmed and `nextCursor` is derived from the
+ * last returned item. With `limit` rows or fewer, `nextCursor` is `null`.
+ *
+ * @param items - The fetched rows, expected to be up to `limit + 1` long.
+ * @param limit - The requested page size that bounds the returned items.
+ * @param toCursor - Maps the last returned item to its ordering keys.
+ * @returns The trimmed page and the next cursor, or `null` on the last page.
+ */
+declare function buildCursorResult<T>(items: T[], limit: number, toCursor: (lastItem: T) => Record<string, string | number>): CursorResult<T>;
+
+export { type CursorQuery, type CursorResult, type PageMeta, type PageQuery, type PageResult, buildCursorResult, buildPageResult, decodeCursor, encodeCursor, normalizeCursorQuery, normalizePageQuery };

package/dist/pagination/index.mjs

@@ -0,0 +1,105 @@
+import { BadRequestException } from '@nestjs/common';
+
+// src/pagination/internal.ts
+var DEFAULT_LIMIT = 20;
+var DEFAULT_MAX_LIMIT = 100;
+var MINIMUM = 1;
+function coercePositiveInt(value, fallback) {
+  if (typeof value !== "number" && typeof value !== "string") {
+    return fallback;
+  }
+  const coerced = Number(value);
+  if (!Number.isFinite(coerced) || coerced < MINIMUM) {
+    return fallback;
+  }
+  return Math.floor(coerced);
+}
+function clampLimit(rawLimit, options) {
+  const defaultLimit = coercePositiveInt(options?.defaultLimit, DEFAULT_LIMIT);
+  const maxLimit = coercePositiveInt(options?.maxLimit, DEFAULT_MAX_LIMIT);
+  return Math.min(coercePositiveInt(rawLimit, defaultLimit), maxLimit);
+}
+
+// src/pagination/offset.ts
+function normalizePageQuery(raw, options) {
+  return {
+    page: coercePositiveInt(raw.page, MINIMUM),
+    limit: clampLimit(raw.limit, options)
+  };
+}
+function buildPageResult(items, totalItems, query) {
+  const safePage = coercePositiveInt(query.page, MINIMUM);
+  const safeTotal = Number.isFinite(totalItems) && totalItems > 0 ? Math.floor(totalItems) : 0;
+  const safeLimit = coercePositiveInt(query.limit, DEFAULT_LIMIT);
+  const totalPages = Math.ceil(safeTotal / safeLimit);
+  return {
+    items,
+    meta: { page: safePage, limit: safeLimit, totalItems: safeTotal, totalPages }
+  };
+}
+
+// src/envelope/error-codes.ts
+var BYMAX_VALIDATION_FAILED = "BYMAX_VALIDATION_FAILED";
+
+// src/pagination/cursor.ts
+var BASE64URL_PATTERN = /^[A-Za-z0-9_-]+$/;
+var CURSOR_REJECTION_MESSAGE = "Malformed pagination cursor.";
+function cursorRejection() {
+  return new BadRequestException({
+    code: BYMAX_VALIDATION_FAILED,
+    message: CURSOR_REJECTION_MESSAGE
+  });
+}
+function isOrderingKeyRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  return Object.values(value).every(
+    (entry) => typeof entry === "string" || typeof entry === "number" && Number.isFinite(entry)
+  );
+}
+function encodeCursor(payload) {
+  const encodable = Object.values(payload).every(
+    (value) => typeof value === "string" || Number.isFinite(value)
+  );
+  if (!encodable) {
+    throw new Error("encodeCursor payload values must each be a string or a finite number.");
+  }
+  return Buffer.from(JSON.stringify(payload), "utf8").toString("base64url");
+}
+function decodeCursor(cursor) {
+  if (!BASE64URL_PATTERN.test(cursor)) {
+    throw cursorRejection();
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+  } catch {
+    throw cursorRejection();
+  }
+  if (!isOrderingKeyRecord(parsed)) {
+    throw cursorRejection();
+  }
+  return parsed;
+}
+function normalizeCursorQuery(raw, options) {
+  const limit = clampLimit(raw.limit, options);
+  if (typeof raw.cursor === "string") {
+    return { cursor: raw.cursor, limit };
+  }
+  return { limit };
+}
+function buildCursorResult(items, limit, toCursor) {
+  const safeLimit = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 0;
+  if (items.length <= safeLimit) {
+    return { items, nextCursor: null };
+  }
+  const page = items.slice(0, safeLimit);
+  const lastItem = page.at(-1);
+  if (lastItem === void 0) {
+    return { items: page, nextCursor: null };
+  }
+  return { items: page, nextCursor: encodeCursor(toCursor(lastItem)) };
+}
+
+export { buildCursorResult, buildPageResult, decodeCursor, encodeCursor, normalizeCursorQuery, normalizePageQuery };

package/package.json

@@ -0,0 +1,169 @@
+{
+  "name": "@bymax-one/nest-core",
+  "version": "1.0.0",
+  "description": "Zero-dependency NestJS 11 application foundation kit: error-envelope exception filter, request-timing interceptor, pagination helpers, health endpoints, and an optional Prometheus metrics endpoint.",
+  "author": "Bymax One <support@bymax.one>",
+  "license": "MIT",
+  "homepage": "https://github.com/bymaxone/nest-core#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bymaxone/nest-core.git"
+  },
+  "bugs": {
+    "url": "https://github.com/bymaxone/nest-core/issues"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.cts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./pagination": {
+      "import": {
+        "types": "./dist/pagination/index.d.ts",
+        "default": "./dist/pagination/index.mjs"
+      },
+      "require": {
+        "types": "./dist/pagination/index.d.cts",
+        "default": "./dist/pagination/index.cjs"
+      }
+    },
+    "./health": {
+      "import": {
+        "types": "./dist/health/index.d.ts",
+        "default": "./dist/health/index.mjs"
+      },
+      "require": {
+        "types": "./dist/health/index.d.cts",
+        "default": "./dist/health/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "lint-staged": {
+    "*.{ts,tsx,js,mjs,cjs}": [
+      "eslint --fix",
+      "prettier --write"
+    ],
+    "*.{json,md,yml,yaml}": [
+      "prettier --write"
+    ]
+  },
+  "dependencies": {},
+  "peerDependencies": {
+    "@nestjs/common": "^11.0.16",
+    "@nestjs/core": "^11.1.18",
+    "reflect-metadata": "^0.2.0",
+    "rxjs": "^7.0.0",
+    "prom-client": "^15.0.0"
+  },
+  "peerDependenciesMeta": {
+    "prom-client": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.2",
+    "@commitlint/cli": "^21.2.1",
+    "@commitlint/config-conventional": "^21.2.0",
+    "@eslint/js": "^9.39.4",
+    "@nestjs/common": "^11.1.20",
+    "@nestjs/core": "^11.1.20",
+    "@nestjs/platform-express": "^11.1.20",
+    "@nestjs/testing": "^11.1.20",
+    "@stryker-mutator/core": "^9",
+    "@stryker-mutator/jest-runner": "^9",
+    "@stryker-mutator/typescript-checker": "^9",
+    "@types/express": "^5.0.6",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^24",
+    "@types/supertest": "^7.2.0",
+    "@typescript-eslint/eslint-plugin": "^8.59.3",
+    "@typescript-eslint/parser": "^8.59.3",
+    "eslint": "^9.39.4",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-import-resolver-typescript": "^4.4.4",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-prettier": "^5.5.5",
+    "eslint-plugin-security": "^4.0.0",
+    "globals": "^17.6.0",
+    "husky": "^9.1.7",
+    "jest": "^30.4.2",
+    "lint-staged": "^17.2.0",
+    "prettier": "^3.8.3",
+    "prom-client": "^15.1.3",
+    "reflect-metadata": "^0.2.2",
+    "rxjs": "^7.8.0",
+    "supertest": "^7.2.2",
+    "ts-jest": "^29.4.9",
+    "ts-node": "^10.9.2",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
+  },
+  "keywords": [
+    "nestjs",
+    "error-envelope",
+    "exception-filter",
+    "request-timing",
+    "pagination",
+    "health-check",
+    "prometheus",
+    "metrics",
+    "typescript"
+  ],
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true,
+    "registry": "https://registry.npmjs.org/"
+  },
+  "module": "./dist/index.mjs",
+  "typesVersions": {
+    "*": {
+      "pagination": [
+        "./dist/pagination/index.d.cts"
+      ],
+      "health": [
+        "./dist/health/index.d.cts"
+      ]
+    }
+  },
+  "scripts": {
+    "build": "pnpm clean && tsup",
+    "check:exports": "attw --pack . --profile strict",
+    "check:published": "node scripts/check-published-surface.mjs",
+    "check:runtime": "node scripts/check-consumer-runtime.mjs",
+    "clean": "node -e \"const fs=require('node:fs');for(const d of ['dist','coverage'])fs.rmSync(d,{recursive:true,force:true})\"",
+    "dogfood": "node scripts/dogfood-smoke-test.mjs",
+    "lint": "eslint --no-error-on-unmatched-pattern src scripts test",
+    "lint:fix": "eslint --no-error-on-unmatched-pattern src scripts test --fix",
+    "mutation": "stryker run",
+    "mutation:dry-run": "stryker run --dryRunOnly",
+    "mutation:incremental": "stryker run --incremental",
+    "release": "npm publish --provenance --access public",
+    "size": "node scripts/check-size.mjs",
+    "test": "jest",
+    "test:cov": "jest --coverage",
+    "test:cov:all": "jest --config jest.coverage.config.ts --coverage",
+    "test:e2e": "jest --config jest.e2e.config.ts",
+    "test:watch": "jest --watch",
+    "typecheck": "tsc --noEmit"
+  }
+}