@vandenberghinc/volt 1.1.2

package/backend/dist/cjs/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/plugins/thread_monitor.js

@@ -0,0 +1,127 @@
+"use strict";
+// import async_hooks from 'async_hooks';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThreadMonitor = void 0;
+// // 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);
+const async_hooks_1 = __importDefault(require("async_hooks"));
+class ThreadMonitor {
+    async_resources = new Map();
+    ignored_types = new Set([
+        'TIMERWRAP',
+        'PROMISE',
+        'RANDOMBYTESREQUEST',
+        'DNSCHANNEL',
+        'Immediate'
+    ]);
+    hook;
+    constructor() {
+        this.hook = async_hooks_1.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) // 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;
+    }
+}
+exports.ThreadMonitor = ThreadMonitor;
+exports.default = ThreadMonitor;

package/backend/dist/cjs/plugins/ts/compiler.d.ts

@@ -0,0 +1,132 @@
+import * as Preprocessing from "./preprocessing.js";
+interface CompilerError {
+    data: string;
+    file_name?: string;
+    line?: number;
+    column?: number;
+}
+/**
+ * Options for bundling TypeScript code.
+ */
+export interface CompileOptions {
+    include?: string[];
+    exclude?: string[];
+    entry_paths?: string[];
+    output: string;
+    error_limit?: number;
+    debug_file?: string;
+    file_by_file?: boolean;
+    /**
+     * Function to preprocess TypeScript code after transpilation.
+     * Receives the file path and its transpiled JavaScript content, returns modified content.
+     */
+    preprocess?: (file_path: string, content: string) => undefined | string | Promise<undefined | string>;
+    /**
+     * TypeScript compiler options.
+     */
+    compiler_opts?: Record<string, any>;
+    exact_files?: boolean;
+    watch?: boolean | {
+        enabled: boolean;
+        log_level?: number;
+        on_change?: (path: string) => any;
+    };
+    extract_exports?: boolean;
+    templates?: Record<string, any>;
+}
+/**
+ * Result of the bundling process.
+ */
+export interface CompileResult {
+    inputs: string[];
+    outputs: string[];
+    /**
+     * Compilation and bundling errors, if any.
+     */
+    errors: CompilerError[];
+    /**
+     * Debug function.
+     */
+    debug: (_watch?: boolean) => void;
+    /**
+     * Function to terminate the watch program. Available only in watch mode.
+     */
+    stop?: () => void;
+    exports: Record<string, string[]>;
+}
+export declare function compile(options: CompileOptions): Promise<CompileResult>;
+/**
+ * Options for bundling TypeScript code.
+ */
+export interface BundleOptions {
+    include?: string[];
+    output?: string;
+    entry_paths?: string[];
+    error_limit?: number;
+    /**
+     * Target platform: 'browser' or 'node'.
+     */
+    platform?: 'browser' | 'node';
+    /**
+     * Target platform: 'ES2023' etc.
+     */
+    target?: string;
+    /**
+     * Output format based on platform.
+     * - For 'browser': 'iife' or 'umd'
+     * - For 'node': 'cjs' or 'esm'
+     */
+    format?: 'iife' | 'cjs' | 'esm';
+    /**
+     * Enable or disable minification.
+     */
+    minify?: boolean;
+    /**
+     * Enable or disable tree shaking.
+     */
+    tree_shaking?: boolean;
+    /**
+     * Enable or disable debug console statements.
+     */
+    debug?: string | boolean;
+    /**
+     * Enable or disable source map generation.
+     */
+    sourcemap?: boolean | 'linked' | 'inline' | 'external' | 'both';
+    extract_inputs?: boolean;
+    /**
+     * Specify which bundler to use: 'esbuild' or 'rollup'.
+     * If undefined, defaults to 'esbuild'.
+     */
+    bundler?: 'esbuild' | 'rollup';
+    opts?: any;
+}
+/**
+ * Result of the bundling process.
+ */
+export interface BundleResult {
+    /**
+     * Bundled JavaScript code.
+     */
+    code?: string;
+    /**
+     * Compilation and bundling errors, if any.
+     */
+    errors: CompilerError[];
+    /**
+     * Source map, if generated.
+     */
+    source_map?: string;
+    /**
+     * Debug function.
+     */
+    debug: () => void;
+    inputs: string[];
+}
+export declare function bundle(options: BundleOptions): Promise<BundleResult>;
+declare const _default: {
+    compile: typeof compile;
+    bundle: typeof bundle;
+    preprocessing: typeof Preprocessing;
+};
+export default _default;