@densetsuuu/docteur 0.1.1-beta.1 → 0.1.1-beta.3

package/README.md

@@ -52,11 +52,12 @@ Interactive TUI for exploring module dependencies.
 docteur xray [options]
 ```
 
-| Option    | Description               | Default         |
-| --------- | ------------------------- | --------------- |
-| `--entry` | Custom entry point        | `bin/server.ts` |
+| Option    | Description        | Default         |
+| --------- | ------------------ | --------------- |
+| `--entry` | Custom entry point | `bin/server.ts` |
 
 **Features:**
+
 - Browse slowest modules
 - Drill down into module dependencies
 - See why a module was loaded (import chain)
@@ -64,6 +65,7 @@ docteur xray [options]
 - Explore provider lifecycle times (register, boot, start, ready)
 
 **Keyboard shortcuts:**
+
 - `↑/↓` Navigate
 - `Enter` Select
 - `Tab` Switch between Modules/Providers view

package/build/src/profiler/collector.d.ts

@@ -6,7 +6,8 @@ export interface PackageGroup {
 }
 export declare class ProfileCollector {
     #private;
-    constructor(modules?: ModuleTiming[], providers?: ProviderTiming[]);
+    constructor(modules?: ModuleTiming[], providerPhases?: Map<string, Record<string, number>>);
+    static buildProviderTimings(phases: Map<string, Record<string, number>>): ProviderTiming[];
     groupAppFilesByCategory(): AppFileGroup[];
     groupModulesByPackage(): PackageGroup[];
     computeSummary(): ProfileSummary;

package/build/src/profiler/collector.js

@@ -12,14 +12,25 @@ import { categories } from './registries/index.js';
 export class ProfileCollector {
     #modules;
     #providers;
-    constructor(modules = [], providers = []) {
+    constructor(modules = [], providerPhases = new Map()) {
         this.#modules = modules;
-        this.#providers = providers;
+        this.#providers = ProfileCollector.buildProviderTimings(providerPhases);
         // Compute subtree times if not already done (skip after filtering to avoid incomplete graph)
         if (modules.length > 0 && modules[0].subtreeTime === undefined) {
             this.#populateSubtreeTimes();
         }
     }
+    static buildProviderTimings(phases) {
+        return [...phases.entries()].map(([name, t]) => ({
+            name,
+            registerTime: t.register || 0,
+            bootTime: t.boot || 0,
+            startTime: t.start || 0,
+            readyTime: t.ready || 0,
+            shutdownTime: t.shutdown || 0,
+            totalTime: (t.register || 0) + (t.boot || 0) + (t.start || 0) + (t.ready || 0),
+        }));
+    }
     #populateSubtreeTimes() {
         const byUrl = new Map(this.#modules.map((m) => [m.resolvedUrl, m]));
         const children = new Map();

package/build/src/profiler/hooks.js

@@ -10,25 +10,13 @@
 */
 import { performance } from 'node:perf_hooks';
 let port;
-const queue = [];
-let pending = false;
-function send(msg) {
-    queue.push(msg);
-    if (!pending) {
-        pending = true;
-        setImmediate(() => {
-            pending = false;
-            port?.postMessage({ type: 'batch', messages: queue.splice(0) });
-        });
-    }
-}
 export function initialize(data) {
     port = data.port;
 }
 export async function resolve(specifier, context, next) {
     const result = await next(specifier, context);
     if (context.parentURL && result.url.startsWith('file://')) {
-        send({ type: 'parent', child: result.url, parent: context.parentURL });
+        port.postMessage({ type: 'parent', child: result.url, parent: context.parentURL });
     }
     return result;
 }
@@ -39,7 +27,7 @@ export async function load(url, context, next) {
     const start = performance.now();
     const result = await next(url, context);
     if (result.format === 'module') {
-        send({ type: 'timing', url, loadTime: performance.now() - start });
+        port.postMessage({ type: 'timing', url, loadTime: performance.now() - start });
     }
     return result;
 }

package/build/src/profiler/loader.js

@@ -7,10 +7,12 @@
 | tracing channels for provider lifecycle timing.
 |
 */
-import { register } from 'node:module';
+import { createRequire, register } from 'node:module';
+import { join } from 'node:path';
 import { performance } from 'node:perf_hooks';
 import { MessageChannel } from 'node:worker_threads';
-const { tracingChannels } = (await import('@adonisjs/application'));
+const require = createRequire(join(process.cwd(), 'node_modules', '_'));
+const { tracingChannels } = require('@adonisjs/application');
 // Module timing data from hooks
 const parents = new Map();
 const loadTimes = new Map();
@@ -20,16 +22,12 @@ const providerStarts = new Map();
 const asyncCalls = new Set();
 // Set up message channel for hooks
 const { port1, port2 } = new MessageChannel();
-port1.unref?.();
+port1.unref();
 port1.on('message', (msg) => {
-    if (msg.type !== 'batch' || !msg.messages)
-        return;
-    for (const m of msg.messages) {
-        if (m.type === 'parent')
-            parents.set(m.child, m.parent);
-        else if (m.type === 'timing')
-            loadTimes.set(m.url, m.loadTime);
-    }
+    if (msg.type === 'parent')
+        parents.set(msg.child, msg.parent);
+    else if (msg.type === 'timing')
+        loadTimes.set(msg.url, msg.loadTime);
 });
 register('./hooks.js', {
     parentURL: import.meta.url,
@@ -39,43 +37,41 @@ register('./hooks.js', {
 // Subscribe to provider lifecycle phases
 // For async methods: start -> end -> asyncStart -> asyncEnd (we wait for asyncEnd)
 // For sync methods: start -> end (we record on end, but defer to check if async fires)
+function getProviderName(msg) {
+    return msg.provider.constructor.name;
+}
+function recordPhase(name, phase, endTime) {
+    const key = `${name}:${phase}`;
+    const start = providerStarts.get(key);
+    if (start === undefined)
+        return;
+    const phases = providerPhases.get(name) || {};
+    phases[phase] = endTime - start;
+    providerPhases.set(name, phases);
+    providerStarts.delete(key);
+}
 function subscribePhase(channel, phase) {
-    const getName = (msg) => msg.provider.constructor.name;
     channel.subscribe({
         start(msg) {
-            providerStarts.set(`${getName(msg)}:${phase}`, performance.now());
+            providerStarts.set(`${getProviderName(msg)}:${phase}`, performance.now());
         },
         end(msg) {
-            const name = getName(msg);
+            const name = getProviderName(msg);
             const key = `${name}:${phase}`;
             const endTime = performance.now();
             // Defer to check if this becomes async (asyncStart fires before our setTimeout)
             setTimeout(() => {
-                if (asyncCalls.has(key))
-                    return;
-                const start = providerStarts.get(key);
-                if (start !== undefined) {
-                    const phases = providerPhases.get(name) || {};
-                    phases[phase] = endTime - start;
-                    providerPhases.set(name, phases);
-                    providerStarts.delete(key);
-                }
+                if (!asyncCalls.has(key))
+                    recordPhase(name, phase, endTime);
             }, 0);
         },
         asyncStart(msg) {
-            asyncCalls.add(`${getName(msg)}:${phase}`);
+            asyncCalls.add(`${getProviderName(msg)}:${phase}`);
         },
         asyncEnd(msg) {
-            const name = getName(msg);
-            const key = `${name}:${phase}`;
-            const start = providerStarts.get(key);
-            if (start !== undefined) {
-                const phases = providerPhases.get(name) || {};
-                phases[phase] = performance.now() - start;
-                providerPhases.set(name, phases);
-                providerStarts.delete(key);
-            }
-            asyncCalls.delete(key);
+            const name = getProviderName(msg);
+            recordPhase(name, phase, performance.now());
+            asyncCalls.delete(`${name}:${phase}`);
         },
         error() { },
     });
@@ -90,21 +86,12 @@ if (process.send) {
     process.on('message', (msg) => {
         if (msg.type !== 'getResults')
             return;
-        const providers = [...providerPhases.entries()].map(([name, t]) => ({
-            name,
-            registerTime: t.register || 0,
-            bootTime: t.boot || 0,
-            startTime: t.start || 0,
-            readyTime: t.ready || 0,
-            shutdownTime: t.shutdown || 0,
-            totalTime: (t.register || 0) + (t.boot || 0) + (t.start || 0) + (t.ready || 0),
-        }));
         process.send({
             type: 'results',
             data: {
                 loadTimes: Object.fromEntries(loadTimes),
                 parents: Object.fromEntries(parents),
-                providers,
+                providerPhases: Object.fromEntries(providerPhases),
             },
         });
     });

package/build/src/profiler/profiler.js

@@ -8,14 +8,13 @@
 |
 */
 import { fork } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
 import { join } from 'node:path';
 import { existsSync } from 'node:fs';
 import { ProfileCollector } from './collector.js';
 import { simplifyUrl } from './reporters/format.js';
 const TIMEOUT_MS = 30_000;
 export function findLoaderPath() {
-    return fileURLToPath(import.meta.resolve('@densetsuuu/docteur/profiler/loader'));
+    return import.meta.resolve('@densetsuuu/docteur/profiler/loader');
 }
 export function findEntryPoint(cwd, entry) {
     const entryPath = join(cwd, entry || 'bin/server.ts');
@@ -37,7 +36,7 @@ function runProfiledProcess(loaderPath, entryPoint, cwd, options) {
     const suppressOutput = options.suppressOutput ?? false;
     return new Promise((resolve, reject) => {
         const state = {
-            providers: [],
+            providerPhases: new Map(),
             loadTimes: new Map(),
             parents: new Map(),
             done: false,
@@ -86,7 +85,7 @@ function runProfiledProcess(loaderPath, entryPoint, cwd, options) {
                 const data = msg.data;
                 state.loadTimes = new Map(Object.entries(data.loadTimes));
                 state.parents = new Map(Object.entries(data.parents || {}));
-                state.providers = data.providers || [];
+                state.providerPhases = new Map(Object.entries(data.providerPhases || {}));
                 complete();
             }
         });
@@ -109,7 +108,7 @@ function buildResults(state, cwd) {
         loadTime,
         parentUrl: state.parents.get(url),
     }));
-    const collector = new ProfileCollector(modules, state.providers);
+    const collector = new ProfileCollector(modules, state.providerPhases);
     const bootTimeMs = state.bootDuration
         ? state.bootDuration[0] * 1000 + state.bootDuration[1] / 1_000_000
         : 0;

package/build/src/profiler/reporters/console_reporter.js

@@ -65,7 +65,7 @@ export class ConsoleReporter {
         ui.logger.log('');
     }
     #printSlowestModules(result, config, cwd) {
-        const collector = new ProfileCollector(result.modules, result.providers);
+        const collector = new ProfileCollector(result.modules);
         const filtered = collector.filterModules(config);
         const slowest = new ProfileCollector(filtered).getTopSlowest(config.topModules);
         if (slowest.length === 0) {
@@ -102,7 +102,7 @@ export class ConsoleReporter {
         ui.logger.log('');
     }
     #printPackageGroups(result, config) {
-        const collector = new ProfileCollector(result.modules, result.providers);
+        const collector = new ProfileCollector(result.modules);
         const filtered = collector.filterModules(config);
         const groups = new ProfileCollector(filtered).groupModulesByPackage();
         if (groups.length === 0) {
@@ -176,7 +176,7 @@ export class ConsoleReporter {
         if (result.summary.totalModules > 500) {
             recommendations.push(`Loading ${result.summary.totalModules} modules. Consider code splitting or lazy imports.`);
         }
-        const collector = new ProfileCollector(result.modules, result.providers);
+        const collector = new ProfileCollector(result.modules);
         const filtered = collector.filterModules(config);
         const verySlowModules = filtered.filter((m) => getEffectiveTime(m) > 100);
         if (verySlowModules.length > 0) {

package/build/src/xray/components/ModuleView.js

@@ -124,7 +124,7 @@ export function ModuleView({ node, tree: _tree, onNavigate, onBack }) {
         }
         onNavigate(item.value);
     };
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { bold: true, color: "cyan", children: [' ', '\uf21e', " Module Details"] }) }), _jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Box, { children: _jsxs(Text, { bold: true, color: "green", children: [' ', node.displayName] }) }), _jsxs(Text, { dimColor: true, children: [" ", node.timing.resolvedUrl] })] }), _jsxs(Box, { marginBottom: 1, flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: " Total time: " }), _jsx(Text, { color: getTimeColor(time), children: formatDuration(time) }), _jsx(Text, { dimColor: true, children: " (with dependencies)" })] }), _jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: " Self time:  " }), _jsx(Text, { color: getTimeColor(selfTime), children: formatDuration(selfTime) }), _jsx(Text, { dimColor: true, children: " (this file only)" })] })] }), lazyImportCandidates.length > 0 && !isDependency(node.timing.resolvedUrl) && (_jsxs(Box, { marginBottom: 1, flexDirection: "column", paddingLeft: 1, children: [_jsxs(Text, { color: "yellow", bold: true, children: [symbols.lightbulb, " Optimization tip:"] }), _jsxs(Text, { dimColor: true, children: [' ', "This file imports ", lazyImportCandidates.length, " heavy package(s) that could be"] }), _jsx(Text, { dimColor: true, children: " lazy-loaded with dynamic imports to reduce cold start time:" }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: " Before: import xlsx from 'xlsx'" }), _jsx(Text, { dimColor: true, children: " After: const xlsx = await import('xlsx')" })] })] })), _jsx(Box, { flexDirection: "column", children: _jsx(SelectInput, { items: items, onSelect: handleSelect, itemComponent: ItemComponent }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: " Left/ESC/Backspace: back | q: quit" }) })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { bold: true, color: "cyan", children: [' ', '\uf21e', " Module Details"] }) }), _jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Box, { children: _jsxs(Text, { bold: true, color: "green", children: [' ', node.displayName] }) }), _jsxs(Text, { dimColor: true, children: [" ", node.timing.resolvedUrl] })] }), _jsxs(Box, { marginBottom: 1, flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: " Total time: " }), _jsx(Text, { color: getTimeColor(time), children: formatDuration(time) }), _jsx(Text, { dimColor: true, children: " (with dependencies)" })] }), _jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: " Self time: " }), _jsx(Text, { color: getTimeColor(selfTime), children: formatDuration(selfTime) }), _jsx(Text, { dimColor: true, children: " (this file only)" })] })] }), lazyImportCandidates.length > 0 && !isDependency(node.timing.resolvedUrl) && (_jsxs(Box, { marginBottom: 1, flexDirection: "column", paddingLeft: 1, children: [_jsxs(Text, { color: "yellow", bold: true, children: [symbols.lightbulb, " Optimization tip:"] }), _jsxs(Text, { dimColor: true, children: [' ', "This file imports ", lazyImportCandidates.length, " heavy package(s) that could be"] }), _jsx(Text, { dimColor: true, children: " lazy-loaded with dynamic imports to reduce cold start time:" }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: " Before: import xlsx from 'xlsx'" }), _jsx(Text, { dimColor: true, children: " After: const xlsx = await import('xlsx')" })] })] })), _jsx(Box, { flexDirection: "column", children: _jsx(SelectInput, { items: items, onSelect: handleSelect, itemComponent: ItemComponent }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: " Left/ESC/Backspace: back | q: quit" }) })] }));
 }
 function extractPackageName(url) {
     const match = url.match(/node_modules\/(@[^/]+\/[^/]+|[^/]+)/);

package/build/src/xray/components/ProviderView.js

@@ -23,9 +23,7 @@ export function ProviderView({ provider, onBack }) {
         { label: 'ready()', value: provider.readyTime },
     ];
     const maxPhaseTime = Math.max(...phases.map((p) => p.value), 1);
-    const items = [
-        { key: 'back', label: `${symbols.arrowLeft} Back`, value: 'back' },
-    ];
+    const items = [{ key: 'back', label: `${symbols.arrowLeft} Back`, value: 'back' }];
     const handleSelect = (item) => {
         if (item.value === 'back') {
             onBack();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@densetsuuu/docteur",
   "description": "AdonisJS cold start profiler - analyze and optimize your application boot time",
-  "version": "0.1.1-beta.1",
+  "version": "0.1.1-beta.3",
   "engines": {
     "node": ">=21.0.0"
   },