@vandenberghinc/volt 1.2.6 → 1.2.7

package/backend/dist/cjs/backend/src/plugins/thread_monitor.d.ts

@@ -0,0 +1,18 @@
+export declare class ThreadMonitor {
+    private async_resources;
+    private ignored_types;
+    private hook;
+    constructor();
+    start(): void;
+    stop(): void;
+    dump_active_resources(options?: {
+        min_age?: number;
+        types?: string[];
+        exclude_types?: string[];
+        include_internal?: boolean;
+    }): void;
+    get_resource_count(): {
+        [key: string]: number;
+    };
+}
+export default ThreadMonitor;

package/backend/dist/cjs/backend/src/plugins/thread_monitor.js

@@ -0,0 +1,116 @@
+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);
+var stdin_exports = {};
+__export(stdin_exports, {
+  ThreadMonitor: () => ThreadMonitor,
+  default: () => stdin_default
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_async_hooks = __toESM(require("async_hooks"));
+class ThreadMonitor {
+  async_resources = /* @__PURE__ */ new Map();
+  ignored_types = /* @__PURE__ */ new Set([
+    "TIMERWRAP",
+    "PROMISE",
+    "RANDOMBYTESREQUEST",
+    "DNSCHANNEL",
+    "Immediate"
+  ]);
+  hook;
+  constructor() {
+    this.hook = import_async_hooks.default.createHook({
+      init: (async_id, type, trigger_id, resource) => {
+        if (this.ignored_types.has(type))
+          return;
+        const err = new Error();
+        const stack = err.stack ? err.stack.split("\n").slice(2).filter((line) => !line.includes("node:internal/")).join("\n") : "No stack available";
+        this.async_resources.set(async_id, {
+          type,
+          stack,
+          timestamp: Date.now(),
+          trigger_id,
+          resource
+        });
+      },
+      destroy: (async_id) => {
+        this.async_resources.delete(async_id);
+      }
+    });
+  }
+  start() {
+    this.hook.enable();
+  }
+  stop() {
+    this.hook.disable();
+  }
+  dump_active_resources(options = {}) {
+    const now = Date.now();
+    let resources = Array.from(this.async_resources.entries());
+    if (typeof options.min_age === "number") {
+      resources = resources.filter(([_, info]) => now - info.timestamp >= options.min_age);
+    }
+    if (options.types != null) {
+      resources = resources.filter(([_, info]) => options.types.includes(info.type));
+    }
+    if (options.exclude_types != null) {
+      resources = resources.filter(([_, info]) => !options.exclude_types.includes(info.type));
+    }
+    if (!options.include_internal != null) {
+      resources = resources.filter(([_, info]) => !info.stack.includes("node:internal/"));
+    }
+    resources.sort((a, b) => a[1].timestamp - b[1].timestamp);
+    console.log("\n=== Active Async Resources ===");
+    if (resources.length === 0) {
+      console.log("No active resources matching criteria");
+      return;
+    }
+    for (const [async_id, info] of resources) {
+      const age = Math.round((now - info.timestamp) / 1e3);
+      console.log(`
+AsyncID: ${async_id}`);
+      console.log(`Type: ${info.type}`);
+      console.log(`Age: ${age}s`);
+      console.log(`Trigger ID: ${info.trigger_id}`);
+      console.log("Stack trace:");
+      console.log(info.stack);
+      console.log("-".repeat(40));
+    }
+  }
+  get_resource_count() {
+    const counts = {};
+    for (const info of this.async_resources.values()) {
+      counts[info.type] = (counts[info.type] || 0) + 1;
+    }
+    return counts;
+  }
+}
+var stdin_default = ThreadMonitor;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ThreadMonitor
+});

package/backend/dist/cjs/backend/src/rate_limit.d.ts

@@ -0,0 +1,148 @@
+/**
+ * @author Daan van den Bergh
+ * @copyright © 2022 - 2025 Daan van den Bergh. All rights reserved
+ */
+import * as https from "https";
+import * as vlib from "@vandenberghinc/vlib";
+import type { Server } from "./server.js";
+export interface RateLimitGroup {
+    /** The rate limit group name. */
+    group?: string | null;
+    /** The maximum requests per rate limit interval. */
+    limit?: number | null;
+    /** The rate limit interval in seconds. */
+    interval?: number | null;
+}
+export interface RateLimitData {
+    /** The rate limit group name. */
+    group: string;
+    /** The maximum requests per rate limit interval. */
+    limit: number;
+    /** The rate limit interval in seconds. */
+    interval: number;
+}
+export interface RateLimitCacheData {
+    count: number;
+    expiration: number;
+}
+/**
+ * The rate limit groups for the endpoint.
+ *
+ * A group can either be registered through this class or by defining the rate limit group on an endpoint using `Endpoint.rate_limit`.
+ *
+ * This class will be accessable under `Server` attribute `rate_limits`.
+ *
+ * @nav Endpoints
+ * @docs
+ */
+export declare namespace RateLimits {
+    const groups: Map<string, RateLimitData>;
+    /**
+     * Add a rate limit group.
+     * @param group  The rate limit group.
+     * @param limit The maximum requests per rate limit interval, defaults to 50.
+     * @param interval The rate limit interval in seconds, defaults to 60.
+     * @docs
+     */
+    function add({ group, limit, interval }: RateLimitGroup): RateLimitData;
+    /**
+     * Normalize an IPv4 or IPv6 address into a unique, canonical string suitable for rate limiting keys.
+     *
+     * Behavior:
+     * - Trims surrounding whitespace.
+     * - If bracketed (`[addr]` or `[addr]:port`), removes brackets (and any trailing port).
+     * - Removes IPv6 zone/scope IDs (`%...`), e.g. `fe80::1%eth0` → `fe80::1`.
+     * - IPv4: returns dotted-decimal without leading zeros (e.g. `001.002.003.004` → `1.2.3.4`).
+     * - IPv6: emits RFC 5952 canonical form (lowercase hex, no leading zeros, single longest `::`).
+     * - IPv4-mapped IPv6 (`::ffff:0:0/96`) is normalized to plain IPv4 (e.g. `::ffff:203.0.113.7` → `203.0.113.7`).
+     *
+     * Notes:
+     * - This function expects a host/address string (not a full URL). It tolerates `[v6]:port`
+     *   but intentionally does **not** accept non-bracketed `ipv4:port`.
+     *
+     * @param ip The input IPv4/IPv6 address.
+     * @returns Canonical address string.
+     * @throws {Error} If the input is not a valid IPv4 or IPv6 address.
+     *
+     * @docs
+     */
+    function normalize_ip(ip: string): string;
+}
+/** Nested types for the {@link RateLimitServer}. */
+export declare namespace RateLimitServer {
+    /**
+     * Constructor options.
+     */
+    interface Opts {
+        /** The port to which the rate limiting server will bind. The default is `51234`. */
+        port?: number;
+        /** The IP address to which the rate limiting server will bind. By default, it runs on localhost only. */
+        ip?: string;
+        /** Enable the https attribute to run on https. */
+        https?: https.ServerOptions;
+    }
+}
+/**
+ * The rate limit websocket class (server).
+ * Rate limiting is handled automatically when the endpoints has it enabled.
+ */
+export declare class RateLimitServer {
+    static default_port: number;
+    private ip;
+    private port;
+    private https_config;
+    private server;
+    private limits;
+    ws?: vlib.websocket.Server;
+    private clear_caches_interval?;
+    constructor({ port, ip, https, _server, }: RateLimitServer.Opts & {
+        _server: Server;
+    });
+    /** Assert the server is running. */
+    private assert_connected;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    limit(ip: string, groups?: RateLimitGroup[]): Promise<number | null>;
+    reset(group: string): Promise<void>;
+    reset_all(): Promise<void>;
+}
+/** Nested types for the {@link RateLimitClient}. */
+export declare namespace RateLimitClient {
+    /**
+     * Constructor options.
+     */
+    interface Opts {
+        /** The port to which the rate limiting server will bind. The default is `51234`. */
+        port?: number;
+        /** The IP address to which the rate limiting server will bind. By default, it runs on localhost only. */
+        ip?: string;
+        /** A boolean flag indicating if the server runs on HTTPS. */
+        https?: boolean;
+        /** The websocket URL of the server. If defined this takes precedence over parameters `ip` and `port`. */
+        url?: string;
+    }
+}
+/**
+ * The secondary rate limit class (client).
+ *
+ * Rate limiting is handled automatically when the endpoints has it enabled.
+ */
+export declare class RateLimitClient {
+    private ip;
+    private port;
+    private https;
+    private url?;
+    private server;
+    ws?: vlib.websocket.Client;
+    constructor({ ip, port, https, url, _server, }: RateLimitClient.Opts & {
+        _server: Server;
+    });
+    /** Assert the client is started & connected. */
+    private assert_connected;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    limit(ip: string, groups?: RateLimitGroup[]): Promise<number | null>;
+    reset(group: string): Promise<void>;
+    reset_all(): Promise<void>;
+}
+export default RateLimits;