aws-cdk 2.1142.0 → 2.1143.0

package/lib/cli/debug-handles.js

@@ -0,0 +1,347 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trackLeakedHandles = trackLeakedHandles;
+const node_async_hooks_1 = require("node:async_hooks");
+const node_fs_1 = require("node:fs");
+const node_url_1 = require("node:url");
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Async resource types we track, with a plain-language description for the report.
+ *
+ * Only libuv *handles*, the resources that can hold the event loop open. Requests
+ * (a DNS lookup, a stream write) have completed by the time the report runs.
+ * `PROMISE` and `TickObject` are excluded on volume alone: they dominate every
+ * async resource a synth creates, and each one would cost a stack capture.
+ *
+ * Every type here exposes `hasRef()`, the only way to tell a handle holding the
+ * loop open from one already closed. `TLSWRAP` has neither `hasRef()` nor a
+ * `destroy` hook, so including it would report every completed HTTPS request as a
+ * leak forever. A leaked TLS connection still surfaces as the `TCPWRAP` under it.
+ */
+const TRACKED_TYPES = {
+    TCPWRAP: 'open network connection',
+    TCPSERVERWRAP: 'listening TCP server',
+    PIPEWRAP: 'open pipe',
+    PIPESERVERWRAP: 'listening pipe server',
+    UDPWRAP: 'open UDP socket',
+    TTYWRAP: 'open terminal stream',
+    Timeout: 'timer from setTimeout or setInterval',
+    Immediate: 'pending setImmediate callback',
+    PROCESSWRAP: 'spawned child process still running',
+    FSEVENTWRAP: 'file-system watcher',
+    STATWATCHER: 'file-system stat watcher',
+    SIGNALWRAP: 'OS signal handler still registered',
+    WORKER: 'worker thread still running',
+    MESSAGEPORT: 'open worker-thread message channel',
+};
+/**
+ * How many stack frames to capture per resource.
+ *
+ * Node's default of 10 is too shallow here. A socket opened through an HTTPS agent
+ * sits behind enough frames of `node:internal/tls/wrap`, `node:https`,
+ * `node:_http_agent` and `node:_http_client` to consume that whole budget, leaving
+ * no application frame for the report to show.
+ */
+const STACK_CAPTURE_DEPTH = 60;
+/**
+ * Grace period before the handle report fires. The timer is unref'd, so it never
+ * fires when Node exits cleanly within this window.
+ */
+const HANDLE_DUMP_GRACE_MS = 1000;
+/**
+ * Cap on how many resources we hold provenance for at once.
+ *
+ * A long-lived command (`cdk watch`, a deploy of many stacks) opens and closes
+ * handles continuously. The `destroy` hook normally removes them again, but types
+ * that never fire it would accumulate for the life of the process. The report says
+ * when the cap was hit, so a truncated list is not read as a complete one.
+ */
+const MAX_TRACKED_HANDLES = 10_000;
+/**
+ * How much of a source line to show beneath a stack frame. Long enough to read a
+ * statement, short enough that one minified line from the bundled CLI cannot
+ * flood the report.
+ */
+const SOURCE_SNIPPET_CHARS = 200;
+/**
+ * Tracks async resources via async_hooks and, on demand, reports the ones still
+ * keeping the event loop alive, with where they were created.
+ *
+ * Nothing is tracked until `start()` runs. Not exported as a value, so the only
+ * way to get one is `trackLeakedHandles()`, which returns a started tracker.
+ */
+class LeakedHandleTracker {
+    watched = new Map();
+    /**
+     * Whether we stopped recording because {@link MAX_TRACKED_HANDLES} was reached.
+     * Reported, so a short list is never mistaken for a complete one.
+     */
+    atCapacity = false;
+    hook = (0, node_async_hooks_1.createHook)({
+        init: (asyncId, type, _triggerAsyncId, resource) => {
+            if (!(type in TRACKED_TYPES)) {
+                return;
+            }
+            if (this.watched.size >= MAX_TRACKED_HANDLES) {
+                this.atCapacity = true;
+                return;
+            }
+            // An exception thrown from an async_hooks callback is not catchable by the
+            // application. Node prints "Error in AsyncHook callback" and aborts the
+            // process, so anything that goes wrong here must cost no more than one
+            // handle's provenance.
+            try {
+                this.watched.set(asyncId, {
+                    type,
+                    handleRef: new WeakRef(resource),
+                    creationStack: captureCreationStack(),
+                });
+            }
+            catch {
+                this.watched.delete(asyncId);
+            }
+        },
+        destroy: (asyncId) => {
+            this.watched.delete(asyncId);
+        },
+    });
+    /**
+     * Begin watching async resources. Must run before the resources we care about
+     * are created, and only when the user opted in, since the hook adds a small
+     * per-resource cost.
+     */
+    start() {
+        this.hook.enable();
+    }
+    /**
+     * Stop watching and discard all tracked state.
+     */
+    stop() {
+        this.hook.disable();
+        this.watched.clear();
+    }
+    /**
+     * Report the leaked handles once the grace period has passed. The timer is
+     * unref'd, so it never fires if the process exits cleanly within the window and
+     * never holds the process open itself.
+     */
+    scheduleReport(ioHelper) {
+        setTimeout(() => {
+            // Runs detached from the CLI's error handling: the command has finished and
+            // there is no one left to hand a rejection to. A diagnostic must not crash
+            // the process it is diagnosing.
+            this.report(ioHelper).catch(() => undefined);
+        }, HANDLE_DUMP_GRACE_MS).unref();
+    }
+    /**
+     * Report every resource still holding the event loop open, each with the source
+     * location where it was created. Call at the very end of execution, by which
+     * point only genuinely leaked handles should remain.
+     *
+     * Emitted as one message, so unrelated output cannot interleave into the middle
+     * of a stack trace, and at DEBUG, which is the level `--debug-cli` raises the
+     * CLI to.
+     */
+    async report(ioHelper) {
+        this.hook.disable();
+        const leaks = [...this.watched.values()].filter((r) => {
+            const handle = r.handleRef.deref();
+            // Already garbage collected, so no longer keeping the loop alive.
+            if (handle === undefined) {
+                return false;
+            }
+            // A fired one-shot timer answers `hasRef() === true` for the rest of the
+            // process and only marks itself `_destroyed`. The `destroy` hook does drop
+            // it from `watched`, but a tick later than this, and timers are the CLI's
+            // most common resource.
+            if (handle._destroyed === true) {
+                return false;
+            }
+            // Ask the handle itself, and believe only a clear yes. A closed socket
+            // answers false, and anything that cannot answer is not evidence of a leak.
+            return typeof handle.hasRef === 'function' && handle.hasRef();
+        });
+        this.watched.clear();
+        await ioHelper.defaults.debug(this.renderReport(leaks).join('\n'));
+    }
+    renderReport(leaks) {
+        if (leaks.length === 0) {
+            // This report only runs because the process was still alive, so something
+            // is holding the loop open. Finding nothing means the cause is outside what
+            // we track, so hand over what Node itself sees.
+            return [
+                'The CLI process is still alive, but no tracked handle explains it.',
+                `Node reports these resources still active: ${activeResourceSummary()}`,
+                'The cause may be a handle opened before tracking started, or a type this build does not track.',
+            ];
+        }
+        const lines = [`${leaks.length} ${leaks.length === 1 ? 'handle' : 'handles'} still keeping the CLI process alive:`];
+        if (this.atCapacity) {
+            lines.push(`Stopped recording after ${MAX_TRACKED_HANDLES} handles, so this list may be incomplete.`);
+        }
+        // One report pass can revisit the same file for every frame of every handle,
+        // and in the published CLI that file is the entire bundle.
+        const sources = new SourceCache();
+        for (const leak of leaks) {
+            lines.push(...describeLeak(leak, sources));
+        }
+        if (sources.sawMinifiedLine) {
+            // The published CLI is one bundled, minified file with no source map, so a
+            // location is a position in the bundle and the snippet beneath it is the
+            // only part that maps back to something recognisable.
+            lines.push('');
+            lines.push('Locations above are positions in the bundled CLI, not in the original source files.');
+        }
+        return lines;
+    }
+}
+function describeLeak(leak, sources) {
+    const frames = actionableFrames(leak.creationStack);
+    const lines = ['', chalk_1.default.bold(`# ${leak.type} (${TRACKED_TYPES[leak.type]})`)];
+    if (frames.length === 0) {
+        lines.push('  (opened entirely inside Node internals, no CLI frames to show)');
+        return lines;
+    }
+    // Headline the function only when it has a real name. Sockets often open from
+    // anonymous internal callbacks, where the name says nothing.
+    const [origin] = frames;
+    if (origin.func && origin.func !== '<anonymous>') {
+        lines.push(`  created in ${origin.func}()`);
+    }
+    lines.push('  call stack:');
+    for (const frame of frames) {
+        // The location is what identifies the frame, so print it even when the file
+        // cannot be read.
+        lines.push(`    ${frame.func} (${frame.file}:${frame.line}:${frame.column})`);
+        const snippet = sources.snippetAt(frame);
+        if (snippet) {
+            lines.push(`      ${chalk_1.default.dim(snippet)}`);
+        }
+    }
+    return lines;
+}
+/**
+ * Capture the call site of the current async resource as structured frames.
+ *
+ * Installs a structured `prepareStackTrace`, captures with this function as the
+ * cut-off, then restores the previous formatter so other stacks are unaffected.
+ *
+ * The cut-off removes this function and everything above it, but the caller is the
+ * tracker's own `init` hook, which sits just below and would otherwise be the top
+ * frame. We drop that frame by position rather than by filename, since after
+ * bundling every frame shares one filename.
+ */
+function captureCreationStack() {
+    const carrier = {};
+    // `Error.prepareStackTrace` is a V8 formatting hook we save and restore, not a
+    // method we invoke, so the unbound-method concern does not apply.
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    const previous = Error.prepareStackTrace;
+    const previousLimit = Error.stackTraceLimit;
+    Error.stackTraceLimit = STACK_CAPTURE_DEPTH;
+    Error.prepareStackTrace = (_error, callSites) => callSites.map((site) => {
+        const file = site.getFileName() ?? '';
+        return {
+            func: site.getFunctionName() ?? '<anonymous>',
+            file: file.startsWith('file://') ? (0, node_url_1.fileURLToPath)(file) : file,
+            line: site.getLineNumber() ?? 0,
+            column: site.getColumnNumber() ?? 0,
+        };
+    });
+    try {
+        Error.captureStackTrace(carrier, captureCreationStack);
+        // Drop the `init` hook frame, always the top one, so the report points at the
+        // code that created the resource rather than at this tracker.
+        return carrier.stack?.slice(1) ?? [];
+    }
+    finally {
+        Error.prepareStackTrace = previous;
+        Error.stackTraceLimit = previousLimit;
+    }
+}
+/**
+ * What Node itself reports as still holding the loop open, as `2x Timeout, 1x TCP`.
+ *
+ * This is the ground truth our own tracking tries to explain, so printing it tells
+ * the reader whether we missed something or the hang is somewhere else.
+ */
+function activeResourceSummary() {
+    const counts = new Map();
+    for (const type of process.getActiveResourcesInfo()) {
+        counts.set(type, (counts.get(type) ?? 0) + 1);
+    }
+    if (counts.size === 0) {
+        return '(none)';
+    }
+    return [...counts].map(([type, count]) => `${count}x ${type}`).join(', ');
+}
+/**
+ * Keep only frames the user can act on by dropping Node internals. Our own `init`
+ * frame is already removed at capture time, see {@link captureCreationStack}.
+ */
+function actionableFrames(frames) {
+    return frames.filter((frame) => frame.file && !frame.file.startsWith('node:'));
+}
+/**
+ * Reads the line of code behind a stack frame, holding each file's lines so a
+ * report pass reads any given file at most once.
+ *
+ * The published CLI is one large bundle, and a single report can hold many frames
+ * pointing into it. Re-reading and re-splitting it per frame stalls the report, at
+ * the moment the user is already waiting on a hung CLI.
+ */
+class SourceCache {
+    /**
+     * Whether any line we read was long enough to be minified rather than
+     * hand-written. Used to warn that the printed locations are bundle-relative.
+     */
+    sawMinifiedLine = false;
+    files = new Map();
+    snippetAt(frame) {
+        const line = this.linesOf(frame.file)?.[frame.line - 1];
+        if (line === undefined) {
+            return undefined;
+        }
+        if (line.length <= SOURCE_SNIPPET_CHARS) {
+            return line.trim() || undefined;
+        }
+        // Too long to be source anyone wrote, so show a window centred on the column
+        // rather than the start of the line.
+        this.sawMinifiedLine = true;
+        const start = Math.max(0, frame.column - 1 - Math.floor(SOURCE_SNIPPET_CHARS / 2));
+        const end = Math.min(line.length, start + SOURCE_SNIPPET_CHARS);
+        const window = line.slice(start, end).trim();
+        return `${start > 0 ? '…' : ''}${window}${end < line.length ? '…' : ''}`;
+    }
+    linesOf(file) {
+        if (!this.files.has(file)) {
+            this.files.set(file, readLines(file));
+        }
+        return this.files.get(file);
+    }
+}
+function readLines(file) {
+    try {
+        return (0, node_fs_1.readFileSync)(file, 'utf-8').split(/\r?\n/);
+    }
+    catch {
+        // Bundled and eval'd frames have filenames that are not on disk. The location
+        // is still reported on its own, so reporting continues without the snippet.
+        return undefined;
+    }
+}
+/**
+ * Start watching async resources and return the tracker doing so.
+ *
+ * Call as early as possible, and only when the user asked for it. The tracker can
+ * only report on resources created after it starts.
+ */
+function trackLeakedHandles() {
+    const tracker = new LeakedHandleTracker();
+    tracker.start();
+    return tracker;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"debug-handles.js","sourceRoot":"","sources":["debug-handles.ts"],"names":[],"mappings":"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","sourcesContent":["import { createHook } from 'node:async_hooks';\nimport { readFileSync } from 'node:fs';\nimport { fileURLToPath } from 'node:url';\nimport chalk from 'chalk';\nimport type { IoHelper } from '../api-private';\n\n/**\n * Async resource types we track, with a plain-language description for the report.\n *\n * Only libuv *handles*, the resources that can hold the event loop open. Requests\n * (a DNS lookup, a stream write) have completed by the time the report runs.\n * `PROMISE` and `TickObject` are excluded on volume alone: they dominate every\n * async resource a synth creates, and each one would cost a stack capture.\n *\n * Every type here exposes `hasRef()`, the only way to tell a handle holding the\n * loop open from one already closed. `TLSWRAP` has neither `hasRef()` nor a\n * `destroy` hook, so including it would report every completed HTTPS request as a\n * leak forever. A leaked TLS connection still surfaces as the `TCPWRAP` under it.\n */\nconst TRACKED_TYPES: Readonly<Record<string, string>> = {\n  TCPWRAP: 'open network connection',\n  TCPSERVERWRAP: 'listening TCP server',\n  PIPEWRAP: 'open pipe',\n  PIPESERVERWRAP: 'listening pipe server',\n  UDPWRAP: 'open UDP socket',\n  TTYWRAP: 'open terminal stream',\n  Timeout: 'timer from setTimeout or setInterval',\n  Immediate: 'pending setImmediate callback',\n  PROCESSWRAP: 'spawned child process still running',\n  FSEVENTWRAP: 'file-system watcher',\n  STATWATCHER: 'file-system stat watcher',\n  SIGNALWRAP: 'OS signal handler still registered',\n  WORKER: 'worker thread still running',\n  MESSAGEPORT: 'open worker-thread message channel',\n};\n\n/**\n * How many stack frames to capture per resource.\n *\n * Node's default of 10 is too shallow here. A socket opened through an HTTPS agent\n * sits behind enough frames of `node:internal/tls/wrap`, `node:https`,\n * `node:_http_agent` and `node:_http_client` to consume that whole budget, leaving\n * no application frame for the report to show.\n */\nconst STACK_CAPTURE_DEPTH = 60;\n\n/**\n * Grace period before the handle report fires. The timer is unref'd, so it never\n * fires when Node exits cleanly within this window.\n */\nconst HANDLE_DUMP_GRACE_MS = 1000;\n\n/**\n * Cap on how many resources we hold provenance for at once.\n *\n * A long-lived command (`cdk watch`, a deploy of many stacks) opens and closes\n * handles continuously. The `destroy` hook normally removes them again, but types\n * that never fire it would accumulate for the life of the process. The report says\n * when the cap was hit, so a truncated list is not read as a complete one.\n */\nconst MAX_TRACKED_HANDLES = 10_000;\n\n/**\n * How much of a source line to show beneath a stack frame. Long enough to read a\n * statement, short enough that one minified line from the bundled CLI cannot\n * flood the report.\n */\nconst SOURCE_SNIPPET_CHARS = 200;\n\n/**\n * One stack frame: the function name, plus the file, line and column, used both to\n * print the location and to read back the line of code.\n *\n * The column is load-bearing. In the published CLI every frame points into one\n * bundled, whitespace-minified file, where the line number barely distinguishes\n * one frame from another.\n */\ninterface SourceFrame {\n  readonly func: string;\n  readonly file: string;\n  readonly line: number;\n  readonly column: number;\n}\n\n/**\n * A resource we are watching: a weak reference to the handle, so tracking does not\n * itself keep it alive, and the stack of where it was created.\n */\ninterface WatchedResource {\n  readonly type: string;\n  readonly handleRef: WeakRef<TrackedHandle>;\n  readonly creationStack: SourceFrame[];\n}\n\n/**\n * The parts of a libuv handle we interrogate. Both are optional because neither is\n * guaranteed: `hasRef` exists only on `HandleWrap`-backed types, and `_destroyed`\n * is a Node internal that only timers set.\n */\ninterface TrackedHandle {\n  _destroyed?: boolean;\n  hasRef?(): boolean;\n}\n\n/**\n * Tracks async resources via async_hooks and, on demand, reports the ones still\n * keeping the event loop alive, with where they were created.\n *\n * Nothing is tracked until `start()` runs. Not exported as a value, so the only\n * way to get one is `trackLeakedHandles()`, which returns a started tracker.\n */\nclass LeakedHandleTracker {\n  private readonly watched = new Map<number, WatchedResource>();\n\n  /**\n   * Whether we stopped recording because {@link MAX_TRACKED_HANDLES} was reached.\n   * Reported, so a short list is never mistaken for a complete one.\n   */\n  private atCapacity = false;\n\n  private readonly hook = createHook({\n    init: (asyncId, type, _triggerAsyncId, resource) => {\n      if (!(type in TRACKED_TYPES)) {\n        return;\n      }\n      if (this.watched.size >= MAX_TRACKED_HANDLES) {\n        this.atCapacity = true;\n        return;\n      }\n      // An exception thrown from an async_hooks callback is not catchable by the\n      // application. Node prints \"Error in AsyncHook callback\" and aborts the\n      // process, so anything that goes wrong here must cost no more than one\n      // handle's provenance.\n      try {\n        this.watched.set(asyncId, {\n          type,\n          handleRef: new WeakRef(resource as TrackedHandle),\n          creationStack: captureCreationStack(),\n        });\n      } catch {\n        this.watched.delete(asyncId);\n      }\n    },\n    destroy: (asyncId) => {\n      this.watched.delete(asyncId);\n    },\n  });\n\n  /**\n   * Begin watching async resources. Must run before the resources we care about\n   * are created, and only when the user opted in, since the hook adds a small\n   * per-resource cost.\n   */\n  public start(): void {\n    this.hook.enable();\n  }\n\n  /**\n   * Stop watching and discard all tracked state.\n   */\n  public stop(): void {\n    this.hook.disable();\n    this.watched.clear();\n  }\n\n  /**\n   * Report the leaked handles once the grace period has passed. The timer is\n   * unref'd, so it never fires if the process exits cleanly within the window and\n   * never holds the process open itself.\n   */\n  public scheduleReport(ioHelper: IoHelper): void {\n    setTimeout(() => {\n      // Runs detached from the CLI's error handling: the command has finished and\n      // there is no one left to hand a rejection to. A diagnostic must not crash\n      // the process it is diagnosing.\n      this.report(ioHelper).catch(() => undefined);\n    }, HANDLE_DUMP_GRACE_MS).unref();\n  }\n\n  /**\n   * Report every resource still holding the event loop open, each with the source\n   * location where it was created. Call at the very end of execution, by which\n   * point only genuinely leaked handles should remain.\n   *\n   * Emitted as one message, so unrelated output cannot interleave into the middle\n   * of a stack trace, and at DEBUG, which is the level `--debug-cli` raises the\n   * CLI to.\n   */\n  public async report(ioHelper: IoHelper): Promise<void> {\n    this.hook.disable();\n\n    const leaks = [...this.watched.values()].filter((r) => {\n      const handle = r.handleRef.deref();\n      // Already garbage collected, so no longer keeping the loop alive.\n      if (handle === undefined) {\n        return false;\n      }\n      // A fired one-shot timer answers `hasRef() === true` for the rest of the\n      // process and only marks itself `_destroyed`. The `destroy` hook does drop\n      // it from `watched`, but a tick later than this, and timers are the CLI's\n      // most common resource.\n      if (handle._destroyed === true) {\n        return false;\n      }\n      // Ask the handle itself, and believe only a clear yes. A closed socket\n      // answers false, and anything that cannot answer is not evidence of a leak.\n      return typeof handle.hasRef === 'function' && handle.hasRef();\n    });\n    this.watched.clear();\n\n    await ioHelper.defaults.debug(this.renderReport(leaks).join('\\n'));\n  }\n\n  private renderReport(leaks: WatchedResource[]): string[] {\n    if (leaks.length === 0) {\n      // This report only runs because the process was still alive, so something\n      // is holding the loop open. Finding nothing means the cause is outside what\n      // we track, so hand over what Node itself sees.\n      return [\n        'The CLI process is still alive, but no tracked handle explains it.',\n        `Node reports these resources still active: ${activeResourceSummary()}`,\n        'The cause may be a handle opened before tracking started, or a type this build does not track.',\n      ];\n    }\n\n    const lines = [`${leaks.length} ${leaks.length === 1 ? 'handle' : 'handles'} still keeping the CLI process alive:`];\n    if (this.atCapacity) {\n      lines.push(`Stopped recording after ${MAX_TRACKED_HANDLES} handles, so this list may be incomplete.`);\n    }\n\n    // One report pass can revisit the same file for every frame of every handle,\n    // and in the published CLI that file is the entire bundle.\n    const sources = new SourceCache();\n    for (const leak of leaks) {\n      lines.push(...describeLeak(leak, sources));\n    }\n\n    if (sources.sawMinifiedLine) {\n      // The published CLI is one bundled, minified file with no source map, so a\n      // location is a position in the bundle and the snippet beneath it is the\n      // only part that maps back to something recognisable.\n      lines.push('');\n      lines.push('Locations above are positions in the bundled CLI, not in the original source files.');\n    }\n\n    return lines;\n  }\n}\n\nfunction describeLeak(leak: WatchedResource, sources: SourceCache): string[] {\n  const frames = actionableFrames(leak.creationStack);\n  const lines = ['', chalk.bold(`# ${leak.type} (${TRACKED_TYPES[leak.type]})`)];\n\n  if (frames.length === 0) {\n    lines.push('  (opened entirely inside Node internals, no CLI frames to show)');\n    return lines;\n  }\n\n  // Headline the function only when it has a real name. Sockets often open from\n  // anonymous internal callbacks, where the name says nothing.\n  const [origin] = frames;\n  if (origin.func && origin.func !== '<anonymous>') {\n    lines.push(`  created in ${origin.func}()`);\n  }\n\n  lines.push('  call stack:');\n  for (const frame of frames) {\n    // The location is what identifies the frame, so print it even when the file\n    // cannot be read.\n    lines.push(`    ${frame.func} (${frame.file}:${frame.line}:${frame.column})`);\n    const snippet = sources.snippetAt(frame);\n    if (snippet) {\n      lines.push(`      ${chalk.dim(snippet)}`);\n    }\n  }\n  return lines;\n}\n\n/**\n * Capture the call site of the current async resource as structured frames.\n *\n * Installs a structured `prepareStackTrace`, captures with this function as the\n * cut-off, then restores the previous formatter so other stacks are unaffected.\n *\n * The cut-off removes this function and everything above it, but the caller is the\n * tracker's own `init` hook, which sits just below and would otherwise be the top\n * frame. We drop that frame by position rather than by filename, since after\n * bundling every frame shares one filename.\n */\nfunction captureCreationStack(): SourceFrame[] {\n  const carrier: { stack?: SourceFrame[] } = {};\n\n  // `Error.prepareStackTrace` is a V8 formatting hook we save and restore, not a\n  // method we invoke, so the unbound-method concern does not apply.\n  // eslint-disable-next-line @typescript-eslint/unbound-method\n  const previous = Error.prepareStackTrace;\n  const previousLimit = Error.stackTraceLimit;\n  Error.stackTraceLimit = STACK_CAPTURE_DEPTH;\n  Error.prepareStackTrace = (_error, callSites) => callSites.map((site) => {\n    const file = site.getFileName() ?? '';\n    return {\n      func: site.getFunctionName() ?? '<anonymous>',\n      file: file.startsWith('file://') ? fileURLToPath(file) : file,\n      line: site.getLineNumber() ?? 0,\n      column: site.getColumnNumber() ?? 0,\n    };\n  });\n  try {\n    Error.captureStackTrace(carrier, captureCreationStack);\n    // Drop the `init` hook frame, always the top one, so the report points at the\n    // code that created the resource rather than at this tracker.\n    return carrier.stack?.slice(1) ?? [];\n  } finally {\n    Error.prepareStackTrace = previous;\n    Error.stackTraceLimit = previousLimit;\n  }\n}\n\n/**\n * What Node itself reports as still holding the loop open, as `2x Timeout, 1x TCP`.\n *\n * This is the ground truth our own tracking tries to explain, so printing it tells\n * the reader whether we missed something or the hang is somewhere else.\n */\nfunction activeResourceSummary(): string {\n  const counts = new Map<string, number>();\n  for (const type of process.getActiveResourcesInfo()) {\n    counts.set(type, (counts.get(type) ?? 0) + 1);\n  }\n  if (counts.size === 0) {\n    return '(none)';\n  }\n  return [...counts].map(([type, count]) => `${count}x ${type}`).join(', ');\n}\n\n/**\n * Keep only frames the user can act on by dropping Node internals. Our own `init`\n * frame is already removed at capture time, see {@link captureCreationStack}.\n */\nfunction actionableFrames(frames: SourceFrame[]): SourceFrame[] {\n  return frames.filter((frame) => frame.file && !frame.file.startsWith('node:'));\n}\n\n/**\n * Reads the line of code behind a stack frame, holding each file's lines so a\n * report pass reads any given file at most once.\n *\n * The published CLI is one large bundle, and a single report can hold many frames\n * pointing into it. Re-reading and re-splitting it per frame stalls the report, at\n * the moment the user is already waiting on a hung CLI.\n */\nclass SourceCache {\n  /**\n   * Whether any line we read was long enough to be minified rather than\n   * hand-written. Used to warn that the printed locations are bundle-relative.\n   */\n  public sawMinifiedLine = false;\n\n  private readonly files = new Map<string, string[] | undefined>();\n\n  public snippetAt(frame: SourceFrame): string | undefined {\n    const line = this.linesOf(frame.file)?.[frame.line - 1];\n    if (line === undefined) {\n      return undefined;\n    }\n    if (line.length <= SOURCE_SNIPPET_CHARS) {\n      return line.trim() || undefined;\n    }\n\n    // Too long to be source anyone wrote, so show a window centred on the column\n    // rather than the start of the line.\n    this.sawMinifiedLine = true;\n    const start = Math.max(0, frame.column - 1 - Math.floor(SOURCE_SNIPPET_CHARS / 2));\n    const end = Math.min(line.length, start + SOURCE_SNIPPET_CHARS);\n    const window = line.slice(start, end).trim();\n    return `${start > 0 ? '…' : ''}${window}${end < line.length ? '…' : ''}`;\n  }\n\n  private linesOf(file: string): string[] | undefined {\n    if (!this.files.has(file)) {\n      this.files.set(file, readLines(file));\n    }\n    return this.files.get(file);\n  }\n}\n\nfunction readLines(file: string): string[] | undefined {\n  try {\n    return readFileSync(file, 'utf-8').split(/\\r?\\n/);\n  } catch {\n    // Bundled and eval'd frames have filenames that are not on disk. The location\n    // is still reported on its own, so reporting continues without the snippet.\n    return undefined;\n  }\n}\n\n/**\n * Start watching async resources and return the tracker doing so.\n *\n * Call as early as possible, and only when the user asked for it. The tracker can\n * only report on resources created after it starts.\n */\nexport function trackLeakedHandles(): LeakedHandleTracker {\n  const tracker = new LeakedHandleTracker();\n  tracker.start();\n  return tracker;\n}\n\nexport type { LeakedHandleTracker };\n"]}