aws-cdk
Version:
AWS CDK Toolkit CLI, the command line tool for CDK apps
347 lines • 45.9 kB
JavaScript
;
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"]}