@vandenberghinc/volt 1.2.4 → 1.2.6

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

@@ -1,18 +0,0 @@
-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/esm/backend/src/plugins/thread_monitor.js

@@ -1,120 +0,0 @@
-// import async_hooks from 'async_hooks';
-// // Map to store details about async resources
-// interface AsyncResourceInfo {
-//   type: string;
-//   stack: string;
-// }
-// const asyncResources = new Map<number, AsyncResourceInfo>();
-// const hook = async_hooks.createHook({
-//     init(asyncId, type, triggerAsyncId, resource) {
-//         // Capture the stack trace at creation time (skip the first two lines)
-//         const err = new Error();
-//         const stack = err.stack ? err.stack.split('\n').slice(2).join('\n') : 'No stack available';
-//         asyncResources.set(asyncId, { type, stack });
-//     },
-//     destroy(asyncId) {
-//         console.log("Destroy", asyncId)
-//         asyncResources.delete(asyncId);
-//     },
-//     // You can also implement other hooks (e.g., before, after) if needed
-// });
-// hook.enable();
-// // Function to dump all active async resources with their stack traces:
-// function dumpActiveAsyncResources() {
-//     console.log("dumpActiveAsyncResources: active async processes")
-//   for (const [asyncId, info] of asyncResources) {
-//     console.log(`\nAsyncID: ${asyncId}, Type: ${info.type}\n`);
-//     console.log(`${info.stack}\n`);
-//   }
-// }
-// // For example, call this in your Server.stop() to inspect what’s still running:
-// // setTimeout(() => {
-// //   dumpActiveAsyncResources();
-// //   hook.disable(); // Optionally disable the hook when done
-// //   console.log('Dump complete. Check async-trace.log for details.');
-// // }, 6000);
-import async_hooks from 'async_hooks';
-export class ThreadMonitor {
-    async_resources = new Map();
-    ignored_types = new Set([
-        'TIMERWRAP',
-        'PROMISE',
-        'RANDOMBYTESREQUEST',
-        'DNSCHANNEL',
-        'Immediate'
-    ]);
-    hook;
-    constructor() {
-        this.hook = async_hooks.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) // Remove first two lines (Error and this function)
-                        .filter(line => !line.includes('node:internal/')) // Filter out Node.js internal calls
-                        .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());
-        // Apply filters
-        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/'));
-        }
-        // Sort by age (oldest first)
-        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) / 1000);
-            console.log(`\nAsyncID: ${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;
-    }
-}
-export default ThreadMonitor;

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

@@ -1,148 +0,0 @@
-/**
- * @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;