Data that was received.
Node.js module
inspector
Not implemented in Bun
Not implemented. Debugging is typically done via standard debugger protocols (like Chrome DevTools Protocol) connected to the Bun process itself, not via this module.
namespace Network
interface DataReceivedEventDataType
- encodedDataLength: number
Actual bytes received (might be less than dataLength for compressed encodings).
interface GetRequestPostDataParameterType
interface GetRequestPostDataReturnType
interface GetResponseBodyParameterType
interface GetResponseBodyReturnType
interface Headers
Request / response headers as keys / values of JSON object.
interface Initiator
Information about the request initiator.
- columnNumber?: number
Initiator column number, set for Parser type or for Script type (when script is importing module) (0-based).
- lineNumber?: number
Initiator line number, set for Parser type or for Script type (when script is importing module) (0-based).
- stack?: StackTrace
Initiator JavaScript stack trace, set for Script only. Requires the Debugger domain to be enabled.
- url?: string
Initiator URL, set for Parser type or for Script type (when script is importing module) or for SignedExchange type.
interface LoadingFailedEventDataType
interface LoadingFinishedEventDataType
interface LoadNetworkResourcePageResult
interface LoadNetworkResourceParameterType
interface StreamResourceContentParameterType
interface StreamResourceContentReturnType
- type MonotonicTime = number
Monotonically increasing time in seconds since an arbitrary point in the past.
- type RequestId = string
Unique request identifier.
- type ResourceType = string
Resource type as it was perceived by the rendering engine.
- type TimeSinceEpoch = number
UTC time in seconds, counted from January 1, 1970.
- ): void;
This feature is only available with the
--experimental-network-inspectionflag enabled.Broadcasts the
Network.dataReceivedevent to connected frontends, or buffers the data ifNetwork.streamResourceContentcommand was not invoked for the given request yet.Also enables
Network.getResponseBodycommand to retrieve the response data. - params: unknown): void;
This feature is only available with the
--experimental-network-inspectionflag enabled.Enables
Network.getRequestPostDatacommand to retrieve the request data. - ): void;
This feature is only available with the
--experimental-network-inspectionflag enabled.Broadcasts the
Network.loadingFailedevent to connected frontends. This event indicates that HTTP request has failed to load. - ): void;
This feature is only available with the
--experimental-network-inspectionflag enabled.Broadcasts the
Network.loadingFinishedevent to connected frontends. This event indicates that HTTP request has finished loading. - ): void;
This feature is only available with the
--experimental-network-inspectionflag enabled.Broadcasts the
Network.requestWillBeSentevent to connected frontends. This event indicates that the application is about to send an HTTP request. - ): void;
This feature is only available with the
--experimental-network-inspectionflag enabled.Broadcasts the
Network.responseReceivedevent to connected frontends. This event indicates that HTTP response is available.
namespace NetworkResources
- url: string,data: string): void;
This feature is only available with the
--experimental-inspector-network-resourceflag enabled.The inspector.NetworkResources.put method is used to provide a response for a loadNetworkResource request issued via the Chrome DevTools Protocol (CDP). This is typically triggered when a source map is specified by URL, and a DevTools frontend—such as Chrome—requests the resource to retrieve the source map.
This method allows developers to predefine the resource content to be served in response to such CDP requests.
const inspector = require('node:inspector'); // By preemptively calling put to register the resource, a source map can be resolved when // a loadNetworkResource request is made from the frontend. async function setNetworkResources() { const mapUrl = 'http://localhost:3000/dist/app.js.map'; const tsUrl = 'http://localhost:3000/src/app.ts'; const distAppJsMap = await fetch(mapUrl).then((res) => res.text()); const srcAppTs = await fetch(tsUrl).then((res) => res.text()); inspector.NetworkResources.put(mapUrl, distAppJsMap); inspector.NetworkResources.put(tsUrl, srcAppTs); }; setNetworkResources().then(() => { require('./dist/app'); });For more details, see the official CDP documentation: Network.loadNetworkResource
class Session
The
inspector.Sessionis used for dispatching messages to the V8 inspector back-end and receiving message responses and notifications.- static captureRejections: boolean
Value: boolean
Change the default
captureRejectionsoption on all newEventEmitterobjects. - readonly static captureRejectionSymbol: typeof captureRejectionSymbol
Value:
Symbol.for('nodejs.rejection')See how to write a custom
rejection handler. - static defaultMaxListeners: number
By default, a maximum of
10listeners can be registered for any single event. This limit can be changed for individualEventEmitterinstances using theemitter.setMaxListeners(n)method. To change the default for allEventEmitterinstances, theevents.defaultMaxListenersproperty can be used. If this value is not a positive number, aRangeErroris thrown.Take caution when setting the
events.defaultMaxListenersbecause the change affects allEventEmitterinstances, including those created before the change is made. However, callingemitter.setMaxListeners(n)still has precedence overevents.defaultMaxListeners.This is not a hard limit. The
EventEmitterinstance will allow more listeners to be added but will output a trace warning to stderr indicating that a "possible EventEmitter memory leak" has been detected. For any singleEventEmitter, theemitter.getMaxListeners()andemitter.setMaxListeners()methods can be used to temporarily avoid this warning:import { EventEmitter } from 'node:events'; const emitter = new EventEmitter(); emitter.setMaxListeners(emitter.getMaxListeners() + 1); emitter.once('event', () => { // do stuff emitter.setMaxListeners(Math.max(emitter.getMaxListeners() - 1, 0)); });The
--trace-warningscommand-line flag can be used to display the stack trace for such warnings.The emitted warning can be inspected with
process.on('warning')and will have the additionalemitter,type, andcountproperties, referring to the event emitter instance, the event's name and the number of attached listeners, respectively. Itsnameproperty is set to'MaxListenersExceededWarning'. - readonly static errorMonitor: typeof errorMonitor
This symbol shall be used to install a listener for only monitoring
'error'events. Listeners installed using this symbol are called before the regular'error'listeners are called.Installing a listener using this symbol does not change the behavior once an
'error'event is emitted. Therefore, the process will still crash if no regular'error'listener is installed. - event: string,listener: (...args: any[]) => void): this;
Alias for
emitter.on(eventName, listener).event: 'inspectorNotification',): this;Emitted when any notification from the V8 Inspector is received.
event: 'Runtime.executionContextCreated',): this;Issued when new execution context is created.
event: 'Runtime.executionContextDestroyed',): this;Issued when execution context is destroyed.
event: 'Runtime.executionContextsCleared',listener: () => void): this;Issued when all executionContexts were cleared in browser
event: 'Runtime.exceptionThrown',): this;Issued when exception was thrown and unhandled.
event: 'Runtime.exceptionRevoked',): this;Issued when unhandled exception was revoked.
event: 'Runtime.consoleAPICalled',): this;Issued when console API was called.
event: 'Runtime.inspectRequested',): this;Issued when object should be inspected (for example, as a result of inspect() command line API call).
event: 'Debugger.scriptParsed',): this;Fired when virtual machine parses script. This event is also fired for all known and uncollected scripts upon enabling debugger.
event: 'Debugger.scriptFailedToParse',): this;Fired when virtual machine fails to parse the script.
event: 'Debugger.breakpointResolved',): this;Fired when breakpoint is resolved to an actual script and location.
event: 'Debugger.paused',): this;Fired when the virtual machine stopped on breakpoint or exception or any other stop criteria.
event: 'Debugger.resumed',listener: () => void): this;Fired when the virtual machine resumed execution.
event: 'Console.messageAdded',): this;Issued when new console message is added.
event: 'Profiler.consoleProfileStarted',): this;Sent when new profile recording is started using console.profile() call.
event: 'Profiler.consoleProfileFinished',): this;event: 'HeapProfiler.addHeapSnapshotChunk',): this;event: 'HeapProfiler.reportHeapSnapshotProgress',): this;event: 'HeapProfiler.lastSeenObjectId',): this;If heap objects tracking has been started then backend regularly sends a current value for last seen object id and corresponding timestamp. If the were changes in the heap since last event then one or more heapStatsUpdate events will be sent before a new lastSeenObjectId event.
event: 'HeapProfiler.heapStatsUpdate',): this;If heap objects tracking has been started then backend may send update for one or more fragments
event: 'NodeTracing.dataCollected',): this;Contains an bucket of collected trace events.
event: 'NodeTracing.tracingComplete',listener: () => void): this;Signals that tracing is stopped and there is no trace buffers pending flush, all data were delivered via dataCollected events.
event: 'NodeWorker.attachedToWorker',): this;Issued when attached to a worker.
event: 'NodeWorker.detachedFromWorker',): this;Issued when detached from the worker.
event: 'NodeWorker.receivedMessageFromWorker',): this;Notifies about a new protocol message received from the session (session ID is provided in attachedToWorker notification).
event: 'Network.requestWillBeSent',): this;Fired when page is about to send HTTP request.
event: 'Network.responseReceived',): this;Fired when HTTP response is available.
event: 'Network.loadingFailed',): this;event: 'Network.loadingFinished',): this;event: 'Network.dataReceived',): this;Fired when data chunk was received over the network.
event: 'NodeRuntime.waitingForDisconnect',listener: () => void): this;This event is fired instead of
Runtime.executionContextDestroyedwhen enabled. It is fired when the Node process finished all code execution and is waiting for all frontends to disconnect.event: 'NodeRuntime.waitingForDebugger',listener: () => void): this;This event is fired when the runtime is waiting for the debugger. For example, when inspector.waitingForDebugger is called
event: 'Target.targetCreated',): this;event: 'Target.attachedToTarget',): this; Connects a session to the inspector back-end.
Connects a session to the inspector back-end. An exception will be thrown if this API was not called on a Worker thread.
Immediately close the session. All pending message callbacks will be called with an error.
session.connect()will need to be called to be able to send messages again. Reconnected session will lose all inspector state, such as enabled agents or configured breakpoints.- emit(event: string | symbol,...args: any[]): boolean;
Synchronously calls each of the listeners registered for the event named
eventName, in the order they were registered, passing the supplied arguments to each.Returns
trueif the event had listeners,falseotherwise.import { EventEmitter } from 'node:events'; const myEmitter = new EventEmitter(); // First listener myEmitter.on('event', function firstListener() { console.log('Helloooo! first listener'); }); // Second listener myEmitter.on('event', function secondListener(arg1, arg2) { console.log(`event with parameters ${arg1}, ${arg2} in second listener`); }); // Third listener myEmitter.on('event', function thirdListener(...args) { const parameters = args.join(', '); console.log(`event with parameters ${parameters} in third listener`); }); console.log(myEmitter.listeners('event')); myEmitter.emit('event', 1, 2, 3, 4, 5); // Prints: // [ // [Function: firstListener], // [Function: secondListener], // [Function: thirdListener] // ] // Helloooo! first listener // event with parameters 1, 2 in second listener // event with parameters 1, 2, 3, 4, 5 in third listener Returns an array listing the events for which the emitter has registered listeners. The values in the array are strings or
Symbols.import { EventEmitter } from 'node:events'; const myEE = new EventEmitter(); myEE.on('foo', () => {}); myEE.on('bar', () => {}); const sym = Symbol('symbol'); myEE.on(sym, () => {}); console.log(myEE.eventNames()); // Prints: [ 'foo', 'bar', Symbol(symbol) ]Returns the current max listener value for the
EventEmitterwhich is either set byemitter.setMaxListeners(n)or defaults to EventEmitter.defaultMaxListeners.- eventName: string | symbol,listener?: Function): number;
Returns the number of listeners listening for the event named
eventName. Iflisteneris provided, it will return how many times the listener is found in the list of the listeners of the event.@param eventNameThe name of the event being listened for
@param listenerThe event handler function
- eventName: string | symbol): Function[];
Returns a copy of the array of listeners for the event named
eventName.server.on('connection', (stream) => { console.log('someone connected!'); }); console.log(util.inspect(server.listeners('connection'))); // Prints: [ [Function] ] - eventName: string | symbol,listener: (...args: any[]) => void): this;
Alias for
emitter.removeListener(). - on(event: string,listener: (...args: any[]) => void): this;
Adds the
listenerfunction to the end of the listeners array for the event namedeventName. No checks are made to see if thelistenerhas already been added. Multiple calls passing the same combination ofeventNameandlistenerwill result in thelistenerbeing added, and called, multiple times.server.on('connection', (stream) => { console.log('someone connected!'); });Returns a reference to the
EventEmitter, so that calls can be chained.By default, event listeners are invoked in the order they are added. The
emitter.prependListener()method can be used as an alternative to add the event listener to the beginning of the listeners array.import { EventEmitter } from 'node:events'; const myEE = new EventEmitter(); myEE.on('foo', () => console.log('a')); myEE.prependListener('foo', () => console.log('b')); myEE.emit('foo'); // Prints: // b // a@param eventThe name of the event.
@param listenerThe callback function
on(event: 'inspectorNotification',): this;Emitted when any notification from the V8 Inspector is received.
on(event: 'Runtime.executionContextsCleared',listener: () => void): this;Issued when all executionContexts were cleared in browser
on(event: 'Runtime.inspectRequested',): this;Issued when object should be inspected (for example, as a result of inspect() command line API call).
on(event: 'Debugger.scriptParsed',): this;Fired when virtual machine parses script. This event is also fired for all known and uncollected scripts upon enabling debugger.
on(event: 'Debugger.scriptFailedToParse',): this;Fired when virtual machine fails to parse the script.
on(event: 'Debugger.breakpointResolved',): this;Fired when breakpoint is resolved to an actual script and location.
on(event: 'Debugger.paused',): this;Fired when the virtual machine stopped on breakpoint or exception or any other stop criteria.
on(event: 'Debugger.resumed',listener: () => void): this;Fired when the virtual machine resumed execution.
on(event: 'Profiler.consoleProfileStarted',): this;Sent when new profile recording is started using console.profile() call.
on(event: 'HeapProfiler.lastSeenObjectId',): this;If heap objects tracking has been started then backend regularly sends a current value for last seen object id and corresponding timestamp. If the were changes in the heap since last event then one or more heapStatsUpdate events will be sent before a new lastSeenObjectId event.
on(event: 'HeapProfiler.heapStatsUpdate',): this;If heap objects tracking has been started then backend may send update for one or more fragments
on(event: 'NodeTracing.tracingComplete',listener: () => void): this;Signals that tracing is stopped and there is no trace buffers pending flush, all data were delivered via dataCollected events.
on(event: 'NodeWorker.receivedMessageFromWorker',): this;Notifies about a new protocol message received from the session (session ID is provided in attachedToWorker notification).
on(event: 'NodeRuntime.waitingForDisconnect',listener: () => void): this;This event is fired instead of
Runtime.executionContextDestroyedwhen enabled. It is fired when the Node process finished all code execution and is waiting for all frontends to disconnect.on(event: 'NodeRuntime.waitingForDebugger',listener: () => void): this;This event is fired when the runtime is waiting for the debugger. For example, when inspector.waitingForDebugger is called
- once(event: string,listener: (...args: any[]) => void): this;
Adds a one-time
listenerfunction for the event namedeventName. The next timeeventNameis triggered, this listener is removed and then invoked.server.once('connection', (stream) => { console.log('Ah, we have our first user!'); });Returns a reference to the
EventEmitter, so that calls can be chained.By default, event listeners are invoked in the order they are added. The
emitter.prependOnceListener()method can be used as an alternative to add the event listener to the beginning of the listeners array.import { EventEmitter } from 'node:events'; const myEE = new EventEmitter(); myEE.once('foo', () => console.log('a')); myEE.prependOnceListener('foo', () => console.log('b')); myEE.emit('foo'); // Prints: // b // a@param eventThe name of the event.
@param listenerThe callback function
once(event: 'inspectorNotification',): this;Emitted when any notification from the V8 Inspector is received.
once(event: 'Runtime.executionContextsCleared',listener: () => void): this;Issued when all executionContexts were cleared in browser
once(event: 'Runtime.inspectRequested',): this;Issued when object should be inspected (for example, as a result of inspect() command line API call).
once(event: 'Debugger.scriptParsed',): this;Fired when virtual machine parses script. This event is also fired for all known and uncollected scripts upon enabling debugger.
once(event: 'Debugger.scriptFailedToParse',): this;Fired when virtual machine fails to parse the script.
once(event: 'Debugger.breakpointResolved',): this;Fired when breakpoint is resolved to an actual script and location.
once(event: 'Debugger.paused',): this;Fired when the virtual machine stopped on breakpoint or exception or any other stop criteria.
once(event: 'Debugger.resumed',listener: () => void): this;Fired when the virtual machine resumed execution.
once(event: 'Profiler.consoleProfileStarted',): this;Sent when new profile recording is started using console.profile() call.
once(event: 'HeapProfiler.lastSeenObjectId',): this;If heap objects tracking has been started then backend regularly sends a current value for last seen object id and corresponding timestamp. If the were changes in the heap since last event then one or more heapStatsUpdate events will be sent before a new lastSeenObjectId event.
once(event: 'HeapProfiler.heapStatsUpdate',): this;If heap objects tracking has been started then backend may send update for one or more fragments
once(event: 'NodeTracing.tracingComplete',listener: () => void): this;Signals that tracing is stopped and there is no trace buffers pending flush, all data were delivered via dataCollected events.
once(event: 'NodeWorker.receivedMessageFromWorker',): this;Notifies about a new protocol message received from the session (session ID is provided in attachedToWorker notification).
once(event: 'NodeRuntime.waitingForDisconnect',listener: () => void): this;This event is fired instead of
Runtime.executionContextDestroyedwhen enabled. It is fired when the Node process finished all code execution and is waiting for all frontends to disconnect.once(event: 'NodeRuntime.waitingForDebugger',listener: () => void): this;This event is fired when the runtime is waiting for the debugger. For example, when inspector.waitingForDebugger is called
- post(method: string,): void;
Posts a message to the inspector back-end.
callbackwill be notified when a response is received.callbackis a function that accepts two optional arguments: error and message-specific result.session.post('Runtime.evaluate', { expression: '2 + 2' }, (error, { result }) => console.log(result)); // Output: { type: 'number', value: 4, description: '4' }The latest version of the V8 inspector protocol is published on the Chrome DevTools Protocol Viewer.
Node.js inspector supports all the Chrome DevTools Protocol domains declared by V8. Chrome DevTools Protocol domain provides an interface for interacting with one of the runtime agents used to inspect the application state and listen to the run-time events.
post(method: 'Runtime.callFunctionOn',): void;Calls function with given declaration on the given object. Object group of the result is inherited from the target object.
post(method: 'Runtime.getProperties',): void;Returns properties of a given object. Object group of the result is inherited from the target object.
post(method: 'Runtime.releaseObjectGroup',): void;Releases all remote objects that belong to a given group.
post(method: 'Runtime.globalLexicalScopeNames',): void;Returns all let, const and class variables from global scope.
post(method: 'Debugger.enable',): void;Enables debugger for the given page. Clients should not assume that the debugging has been enabled until the result for this command is received.
post(method: 'Debugger.setBreakpointsActive',): void;Activates / deactivates all breakpoints on the page.
post(method: 'Debugger.setSkipAllPauses',): void;Makes page not interrupt on any pauses (breakpoint, exception, dom exception etc).
post(method: 'Debugger.setBreakpointByUrl',): void;Sets JavaScript breakpoint at given location specified either by URL or URL regex. Once this command is issued, all existing parsed scripts will have breakpoints resolved and returned in <code>locations</code> property. Further matching script parsing will result in subsequent <code>breakpointResolved</code> events issued. This logical breakpoint will survive page reloads.
post(method: 'Debugger.getPossibleBreakpoints',): void;Returns possible locations for breakpoint. scriptId in start and end range locations should be the same.
post(method: 'Debugger.continueToLocation',): void;Continues execution until specific location is reached.
post(method: 'Debugger.getStackTrace',): void;Returns stack trace with given <code>stackTraceId</code>.
post(method: 'Debugger.setPauseOnExceptions',): void;Defines pause on exceptions state. Can be set to stop on all exceptions, uncaught exceptions or no exceptions. Initial pause on exceptions state is <code>none</code>.
post(method: 'Debugger.setVariableValue',): void;Changes value of variable in a callframe. Object-based scopes are not supported and must be mutated manually.
post(method: 'Debugger.setReturnValue',): void;Changes return value in top frame. Available only at return break position.
post(method: 'Debugger.setAsyncCallStackDepth',): void;Enables or disables async call stacks tracking.
post(method: 'Debugger.setBlackboxPatterns',): void;Replace previous blackbox patterns with passed ones. Forces backend to skip stepping/pausing in scripts with url matching one of the patterns. VM will try to leave blackboxed script by performing 'step in' several times, finally resorting to 'step out' if unsuccessful.
post(method: 'Debugger.setBlackboxedRanges',): void;Makes backend skip steps in the script in blackboxed ranges. VM will try leave blacklisted scripts by performing 'step in' several times, finally resorting to 'step out' if unsuccessful. Positions array contains positions where blackbox state is changed. First interval isn't blackboxed. Array should be sorted.
post(method: 'Profiler.setSamplingInterval',): void;Changes CPU profiler sampling interval. Must be called before CPU profiles recording started.
post(method: 'Profiler.startPreciseCoverage',): void;Enable precise code coverage. Coverage data for JavaScript executed before enabling precise code coverage may be incomplete. Enabling prevents running optimized code and resets execution counters.
post(method: 'Profiler.takePreciseCoverage',): void;Collect coverage data for the current isolate, and resets execution counters. Precise code coverage needs to have started.
post(method: 'Profiler.getBestEffortCoverage',): void;Collect coverage data for the current isolate. The coverage data may be incomplete due to garbage collection.
post(method: 'HeapProfiler.addInspectedHeapObject',): void;Enables console to refer to the node with given id via $x (see Command Line API for more details $x functions).
post(method: 'NodeWorker.sendMessageToWorker',): void;Sends protocol message over session with given id.
post(method: 'NodeWorker.enable',): void;Instructs the inspector to attach to running workers. Will also attach to new workers as they start
post(method: 'Network.getRequestPostData',): void;Returns post data sent with the request. Returns an error when no data was sent with the request.
post(method: 'Network.streamResourceContent',): void;Enables streaming of the response for the given requestId. If enabled, the dataReceived event contains the data that was received during streaming.
post(method: 'NodeRuntime.notifyWhenWaitingForDisconnect',): void;Enable the
NodeRuntime.waitingForDisconnect. - event: string,listener: (...args: any[]) => void): this;
Adds the
listenerfunction to the beginning of the listeners array for the event namedeventName. No checks are made to see if thelistenerhas already been added. Multiple calls passing the same combination ofeventNameandlistenerwill result in thelistenerbeing added, and called, multiple times.server.prependListener('connection', (stream) => { console.log('someone connected!'); });Returns a reference to the
EventEmitter, so that calls can be chained.@param eventThe name of the event.
@param listenerThe callback function
event: 'inspectorNotification',): this;Emitted when any notification from the V8 Inspector is received.
event: 'Runtime.executionContextCreated',): this;Issued when new execution context is created.
event: 'Runtime.executionContextDestroyed',): this;Issued when execution context is destroyed.
event: 'Runtime.executionContextsCleared',listener: () => void): this;Issued when all executionContexts were cleared in browser
event: 'Runtime.exceptionThrown',): this;Issued when exception was thrown and unhandled.
event: 'Runtime.exceptionRevoked',): this;Issued when unhandled exception was revoked.
event: 'Runtime.consoleAPICalled',): this;Issued when console API was called.
event: 'Runtime.inspectRequested',): this;Issued when object should be inspected (for example, as a result of inspect() command line API call).
event: 'Debugger.scriptParsed',): this;Fired when virtual machine parses script. This event is also fired for all known and uncollected scripts upon enabling debugger.
event: 'Debugger.scriptFailedToParse',): this;Fired when virtual machine fails to parse the script.
event: 'Debugger.breakpointResolved',): this;Fired when breakpoint is resolved to an actual script and location.
event: 'Debugger.paused',): this;Fired when the virtual machine stopped on breakpoint or exception or any other stop criteria.
event: 'Debugger.resumed',listener: () => void): this;Fired when the virtual machine resumed execution.
event: 'Console.messageAdded',): this;Issued when new console message is added.
event: 'Profiler.consoleProfileStarted',): this;Sent when new profile recording is started using console.profile() call.
event: 'Profiler.consoleProfileFinished',): this;event: 'HeapProfiler.addHeapSnapshotChunk',): this;event: 'HeapProfiler.reportHeapSnapshotProgress',): this;event: 'HeapProfiler.lastSeenObjectId',): this;If heap objects tracking has been started then backend regularly sends a current value for last seen object id and corresponding timestamp. If the were changes in the heap since last event then one or more heapStatsUpdate events will be sent before a new lastSeenObjectId event.
event: 'HeapProfiler.heapStatsUpdate',): this;If heap objects tracking has been started then backend may send update for one or more fragments
event: 'NodeTracing.dataCollected',): this;Contains an bucket of collected trace events.
event: 'NodeTracing.tracingComplete',listener: () => void): this;Signals that tracing is stopped and there is no trace buffers pending flush, all data were delivered via dataCollected events.
event: 'NodeWorker.attachedToWorker',): this;Issued when attached to a worker.
event: 'NodeWorker.detachedFromWorker',): this;Issued when detached from the worker.
event: 'NodeWorker.receivedMessageFromWorker',): this;Notifies about a new protocol message received from the session (session ID is provided in attachedToWorker notification).
event: 'Network.requestWillBeSent',): this;Fired when page is about to send HTTP request.
event: 'Network.responseReceived',): this;Fired when HTTP response is available.
event: 'Network.loadingFailed',): this;event: 'Network.loadingFinished',): this;event: 'Network.dataReceived',): this;Fired when data chunk was received over the network.
event: 'NodeRuntime.waitingForDisconnect',listener: () => void): this;This event is fired instead of
Runtime.executionContextDestroyedwhen enabled. It is fired when the Node process finished all code execution and is waiting for all frontends to disconnect.event: 'NodeRuntime.waitingForDebugger',listener: () => void): this;This event is fired when the runtime is waiting for the debugger. For example, when inspector.waitingForDebugger is called
event: 'Target.targetCreated',): this;event: 'Target.attachedToTarget',): this; - event: string,listener: (...args: any[]) => void): this;
Adds a one-time
listenerfunction for the event namedeventNameto the beginning of the listeners array. The next timeeventNameis triggered, this listener is removed, and then invoked.server.prependOnceListener('connection', (stream) => { console.log('Ah, we have our first user!'); });Returns a reference to the
EventEmitter, so that calls can be chained.@param eventThe name of the event.
@param listenerThe callback function
event: 'inspectorNotification',): this;Emitted when any notification from the V8 Inspector is received.
event: 'Runtime.executionContextCreated',): this;Issued when new execution context is created.
event: 'Runtime.executionContextDestroyed',): this;Issued when execution context is destroyed.
event: 'Runtime.executionContextsCleared',listener: () => void): this;Issued when all executionContexts were cleared in browser
event: 'Runtime.exceptionThrown',): this;Issued when exception was thrown and unhandled.
event: 'Runtime.exceptionRevoked',): this;Issued when unhandled exception was revoked.
event: 'Runtime.consoleAPICalled',): this;Issued when console API was called.
event: 'Runtime.inspectRequested',): this;Issued when object should be inspected (for example, as a result of inspect() command line API call).
event: 'Debugger.scriptParsed',): this;Fired when virtual machine parses script. This event is also fired for all known and uncollected scripts upon enabling debugger.
event: 'Debugger.scriptFailedToParse',): this;Fired when virtual machine fails to parse the script.
event: 'Debugger.breakpointResolved',): this;Fired when breakpoint is resolved to an actual script and location.
event: 'Debugger.paused',): this;Fired when the virtual machine stopped on breakpoint or exception or any other stop criteria.
event: 'Debugger.resumed',listener: () => void): this;Fired when the virtual machine resumed execution.
event: 'Console.messageAdded',): this;Issued when new console message is added.
event: 'Profiler.consoleProfileStarted',): this;Sent when new profile recording is started using console.profile() call.
event: 'Profiler.consoleProfileFinished',): this;event: 'HeapProfiler.addHeapSnapshotChunk',): this;event: 'HeapProfiler.reportHeapSnapshotProgress',): this;event: 'HeapProfiler.lastSeenObjectId',): this;If heap objects tracking has been started then backend regularly sends a current value for last seen object id and corresponding timestamp. If the were changes in the heap since last event then one or more heapStatsUpdate events will be sent before a new lastSeenObjectId event.
event: 'HeapProfiler.heapStatsUpdate',): this;If heap objects tracking has been started then backend may send update for one or more fragments
event: 'NodeTracing.dataCollected',): this;Contains an bucket of collected trace events.
event: 'NodeTracing.tracingComplete',listener: () => void): this;Signals that tracing is stopped and there is no trace buffers pending flush, all data were delivered via dataCollected events.
event: 'NodeWorker.attachedToWorker',): this;Issued when attached to a worker.
event: 'NodeWorker.detachedFromWorker',): this;Issued when detached from the worker.
event: 'NodeWorker.receivedMessageFromWorker',): this;Notifies about a new protocol message received from the session (session ID is provided in attachedToWorker notification).
event: 'Network.requestWillBeSent',): this;Fired when page is about to send HTTP request.
event: 'Network.responseReceived',): this;Fired when HTTP response is available.
event: 'Network.loadingFailed',): this;event: 'Network.loadingFinished',): this;event: 'Network.dataReceived',): this;Fired when data chunk was received over the network.
event: 'NodeRuntime.waitingForDisconnect',listener: () => void): this;This event is fired instead of
Runtime.executionContextDestroyedwhen enabled. It is fired when the Node process finished all code execution and is waiting for all frontends to disconnect.event: 'NodeRuntime.waitingForDebugger',listener: () => void): this;This event is fired when the runtime is waiting for the debugger. For example, when inspector.waitingForDebugger is called
event: 'Target.targetCreated',): this;event: 'Target.attachedToTarget',): this; - eventName: string | symbol): Function[];
Returns a copy of the array of listeners for the event named
eventName, including any wrappers (such as those created by.once()).import { EventEmitter } from 'node:events'; const emitter = new EventEmitter(); emitter.once('log', () => console.log('log once')); // Returns a new Array with a function `onceWrapper` which has a property // `listener` which contains the original listener bound above const listeners = emitter.rawListeners('log'); const logFnWrapper = listeners[0]; // Logs "log once" to the console and does not unbind the `once` event logFnWrapper.listener(); // Logs "log once" to the console and removes the listener logFnWrapper(); emitter.on('log', () => console.log('log persistently')); // Will return a new Array with a single function bound by `.on()` above const newListeners = emitter.rawListeners('log'); // Logs "log persistently" twice newListeners[0](); emitter.emit('log'); - eventName?: string | symbol): this;
Removes all listeners, or those of the specified
eventName.It is bad practice to remove listeners added elsewhere in the code, particularly when the
EventEmitterinstance was created by some other component or module (e.g. sockets or file streams).Returns a reference to the
EventEmitter, so that calls can be chained. - eventName: string | symbol,listener: (...args: any[]) => void): this;
Removes the specified
listenerfrom the listener array for the event namedeventName.const callback = (stream) => { console.log('someone connected!'); }; server.on('connection', callback); // ... server.removeListener('connection', callback);removeListener()will remove, at most, one instance of a listener from the listener array. If any single listener has been added multiple times to the listener array for the specifiedeventName, thenremoveListener()must be called multiple times to remove each instance.Once an event is emitted, all listeners attached to it at the time of emitting are called in order. This implies that any
removeListener()orremoveAllListeners()calls after emitting and before the last listener finishes execution will not remove them fromemit()in progress. Subsequent events behave as expected.import { EventEmitter } from 'node:events'; class MyEmitter extends EventEmitter {} const myEmitter = new MyEmitter(); const callbackA = () => { console.log('A'); myEmitter.removeListener('event', callbackB); }; const callbackB = () => { console.log('B'); }; myEmitter.on('event', callbackA); myEmitter.on('event', callbackB); // callbackA removes listener callbackB but it will still be called. // Internal listener array at time of emit [callbackA, callbackB] myEmitter.emit('event'); // Prints: // A // B // callbackB is now removed. // Internal listener array [callbackA] myEmitter.emit('event'); // Prints: // ABecause listeners are managed using an internal array, calling this will change the position indices of any listener registered after the listener being removed. This will not impact the order in which listeners are called, but it means that any copies of the listener array as returned by the
emitter.listeners()method will need to be recreated.When a single function has been added as a handler multiple times for a single event (as in the example below),
removeListener()will remove the most recently added instance. In the example theonce('ping')listener is removed:import { EventEmitter } from 'node:events'; const ee = new EventEmitter(); function pong() { console.log('pong'); } ee.on('ping', pong); ee.once('ping', pong); ee.removeListener('ping', pong); ee.emit('ping'); ee.emit('ping');Returns a reference to the
EventEmitter, so that calls can be chained. - n: number): this;
By default
EventEmitters will print a warning if more than10listeners are added for a particular event. This is a useful default that helps finding memory leaks. Theemitter.setMaxListeners()method allows the limit to be modified for this specificEventEmitterinstance. The value can be set toInfinity(or0) to indicate an unlimited number of listeners.Returns a reference to the
EventEmitter, so that calls can be chained. - ): Disposable;
Listens once to the
abortevent on the providedsignal.Listening to the
abortevent on abort signals is unsafe and may lead to resource leaks since another third party with the signal can calle.stopImmediatePropagation(). Unfortunately Node.js cannot change this since it would violate the web standard. Additionally, the original API makes it easy to forget to remove listeners.This API allows safely using
AbortSignals in Node.js APIs by solving these two issues by listening to the event such thatstopImmediatePropagationdoes not prevent the listener from running.Returns a disposable so that it may be unsubscribed from more easily.
import { addAbortListener } from 'node:events'; function example(signal) { let disposable; try { signal.addEventListener('abort', (e) => e.stopImmediatePropagation()); disposable = addAbortListener(signal, (e) => { // Do something when signal is aborted. }); } finally { disposable?.[Symbol.dispose](); } }@returnsDisposable that removes the
abortlistener. - name: string | symbol): Function[];
Returns a copy of the array of listeners for the event named
eventName.For
EventEmitters this behaves exactly the same as calling.listenerson the emitter.For
EventTargets this is the only way to get the event listeners for the event target. This is useful for debugging and diagnostic purposes.import { getEventListeners, EventEmitter } from 'node:events'; { const ee = new EventEmitter(); const listener = () => console.log('Events are fun'); ee.on('foo', listener); console.log(getEventListeners(ee, 'foo')); // [ [Function: listener] ] } { const et = new EventTarget(); const listener = () => console.log('Events are fun'); et.addEventListener('foo', listener); console.log(getEventListeners(et, 'foo')); // [ [Function: listener] ] } - ): number;
Returns the currently set max amount of listeners.
For
EventEmitters this behaves exactly the same as calling.getMaxListenerson the emitter.For
EventTargets this is the only way to get the max event listeners for the event target. If the number of event handlers on a single EventTarget exceeds the max set, the EventTarget will print a warning.import { getMaxListeners, setMaxListeners, EventEmitter } from 'node:events'; { const ee = new EventEmitter(); console.log(getMaxListeners(ee)); // 10 setMaxListeners(11, ee); console.log(getMaxListeners(ee)); // 11 } { const et = new EventTarget(); console.log(getMaxListeners(et)); // 10 setMaxListeners(11, et); console.log(getMaxListeners(et)); // 11 } - emitter: EventEmitter,eventName: string | symbol,options?: StaticEventEmitterIteratorOptions): AsyncIterator<any[]>;
import { on, EventEmitter } from 'node:events'; import process from 'node:process'; const ee = new EventEmitter(); // Emit later on process.nextTick(() => { ee.emit('foo', 'bar'); ee.emit('foo', 42); }); for await (const event of on(ee, 'foo')) { // The execution of this inner block is synchronous and it // processes one event at a time (even with await). Do not use // if concurrent execution is required. console.log(event); // prints ['bar'] [42] } // Unreachable hereReturns an
AsyncIteratorthat iterateseventNameevents. It will throw if theEventEmitteremits'error'. It removes all listeners when exiting the loop. Thevaluereturned by each iteration is an array composed of the emitted event arguments.An
AbortSignalcan be used to cancel waiting on events:import { on, EventEmitter } from 'node:events'; import process from 'node:process'; const ac = new AbortController(); (async () => { const ee = new EventEmitter(); // Emit later on process.nextTick(() => { ee.emit('foo', 'bar'); ee.emit('foo', 42); }); for await (const event of on(ee, 'foo', { signal: ac.signal })) { // The execution of this inner block is synchronous and it // processes one event at a time (even with await). Do not use // if concurrent execution is required. console.log(event); // prints ['bar'] [42] } // Unreachable here })(); process.nextTick(() => ac.abort());Use the
closeoption to specify an array of event names that will end the iteration:import { on, EventEmitter } from 'node:events'; import process from 'node:process'; const ee = new EventEmitter(); // Emit later on process.nextTick(() => { ee.emit('foo', 'bar'); ee.emit('foo', 42); ee.emit('close'); }); for await (const event of on(ee, 'foo', { close: ['close'] })) { console.log(event); // prints ['bar'] [42] } // the loop will exit after 'close' is emitted console.log('done'); // prints 'done'@returnsAn
AsyncIteratorthat iterateseventNameevents emitted by theemittereventName: string,options?: StaticEventEmitterIteratorOptions): AsyncIterator<any[]>;import { on, EventEmitter } from 'node:events'; import process from 'node:process'; const ee = new EventEmitter(); // Emit later on process.nextTick(() => { ee.emit('foo', 'bar'); ee.emit('foo', 42); }); for await (const event of on(ee, 'foo')) { // The execution of this inner block is synchronous and it // processes one event at a time (even with await). Do not use // if concurrent execution is required. console.log(event); // prints ['bar'] [42] } // Unreachable hereReturns an
AsyncIteratorthat iterateseventNameevents. It will throw if theEventEmitteremits'error'. It removes all listeners when exiting the loop. Thevaluereturned by each iteration is an array composed of the emitted event arguments.An
AbortSignalcan be used to cancel waiting on events:import { on, EventEmitter } from 'node:events'; import process from 'node:process'; const ac = new AbortController(); (async () => { const ee = new EventEmitter(); // Emit later on process.nextTick(() => { ee.emit('foo', 'bar'); ee.emit('foo', 42); }); for await (const event of on(ee, 'foo', { signal: ac.signal })) { // The execution of this inner block is synchronous and it // processes one event at a time (even with await). Do not use // if concurrent execution is required. console.log(event); // prints ['bar'] [42] } // Unreachable here })(); process.nextTick(() => ac.abort());Use the
closeoption to specify an array of event names that will end the iteration:import { on, EventEmitter } from 'node:events'; import process from 'node:process'; const ee = new EventEmitter(); // Emit later on process.nextTick(() => { ee.emit('foo', 'bar'); ee.emit('foo', 42); ee.emit('close'); }); for await (const event of on(ee, 'foo', { close: ['close'] })) { console.log(event); // prints ['bar'] [42] } // the loop will exit after 'close' is emitted console.log('done'); // prints 'done'@returnsAn
AsyncIteratorthat iterateseventNameevents emitted by theemitter - emitter: EventEmitter,eventName: string | symbol,options?: StaticEventEmitterOptions): Promise<any[]>;
Creates a
Promisethat is fulfilled when theEventEmitteremits the given event or that is rejected if theEventEmitteremits'error'while waiting. ThePromisewill resolve with an array of all the arguments emitted to the given event.This method is intentionally generic and works with the web platform EventTarget interface, which has no special
'error'event semantics and does not listen to the'error'event.import { once, EventEmitter } from 'node:events'; import process from 'node:process'; const ee = new EventEmitter(); process.nextTick(() => { ee.emit('myevent', 42); }); const [value] = await once(ee, 'myevent'); console.log(value); const err = new Error('kaboom'); process.nextTick(() => { ee.emit('error', err); }); try { await once(ee, 'myevent'); } catch (err) { console.error('error happened', err); }The special handling of the
'error'event is only used whenevents.once()is used to wait for another event. Ifevents.once()is used to wait for the 'error'event itself, then it is treated as any other kind of event without special handling:import { EventEmitter, once } from 'node:events'; const ee = new EventEmitter(); once(ee, 'error') .then(([err]) => console.log('ok', err.message)) .catch((err) => console.error('error', err.message)); ee.emit('error', new Error('boom')); // Prints: ok boomAn
AbortSignalcan be used to cancel waiting for the event:import { EventEmitter, once } from 'node:events'; const ee = new EventEmitter(); const ac = new AbortController(); async function foo(emitter, event, signal) { try { await once(emitter, event, { signal }); console.log('event emitted!'); } catch (error) { if (error.name === 'AbortError') { console.error('Waiting for the event was canceled!'); } else { console.error('There was an error', error.message); } } } foo(ee, 'foo', ac.signal); ac.abort(); // Abort waiting for the event ee.emit('foo'); // Prints: Waiting for the event was canceled!eventName: string,options?: StaticEventEmitterOptions): Promise<any[]>;Creates a
Promisethat is fulfilled when theEventEmitteremits the given event or that is rejected if theEventEmitteremits'error'while waiting. ThePromisewill resolve with an array of all the arguments emitted to the given event.This method is intentionally generic and works with the web platform EventTarget interface, which has no special
'error'event semantics and does not listen to the'error'event.import { once, EventEmitter } from 'node:events'; import process from 'node:process'; const ee = new EventEmitter(); process.nextTick(() => { ee.emit('myevent', 42); }); const [value] = await once(ee, 'myevent'); console.log(value); const err = new Error('kaboom'); process.nextTick(() => { ee.emit('error', err); }); try { await once(ee, 'myevent'); } catch (err) { console.error('error happened', err); }The special handling of the
'error'event is only used whenevents.once()is used to wait for another event. Ifevents.once()is used to wait for the 'error'event itself, then it is treated as any other kind of event without special handling:import { EventEmitter, once } from 'node:events'; const ee = new EventEmitter(); once(ee, 'error') .then(([err]) => console.log('ok', err.message)) .catch((err) => console.error('error', err.message)); ee.emit('error', new Error('boom')); // Prints: ok boomAn
AbortSignalcan be used to cancel waiting for the event:import { EventEmitter, once } from 'node:events'; const ee = new EventEmitter(); const ac = new AbortController(); async function foo(emitter, event, signal) { try { await once(emitter, event, { signal }); console.log('event emitted!'); } catch (error) { if (error.name === 'AbortError') { console.error('Waiting for the event was canceled!'); } else { console.error('There was an error', error.message); } } } foo(ee, 'foo', ac.signal); ac.abort(); // Abort waiting for the event ee.emit('foo'); // Prints: Waiting for the event was canceled! - n?: number,): void;
import { setMaxListeners, EventEmitter } from 'node:events'; const target = new EventTarget(); const emitter = new EventEmitter(); setMaxListeners(5, target, emitter);@param nA non-negative number. The maximum number of listeners per
EventTargetevent.@param eventTargetsZero or more {EventTarget} or {EventEmitter} instances. If none are specified,
nis set as the default max for all newly created {EventTarget} and {EventEmitter} objects.
An object to send messages to the remote inspector console.
Deactivate the inspector. Blocks until there are no active connections.
- port?: number,host?: string,wait?: boolean): Disposable;
Activate inspector on host and port. Equivalent to
node --inspect=[[host:]port], but can be done programmatically after node has started.If wait is
true, will block until a client has connected to the inspect port and flow control has been passed to the debugger client.See the security warning regarding the
hostparameter usage.@param portPort to listen on for inspector connections. Defaults to what was specified on the CLI.
@param hostHost to listen on for inspector connections. Defaults to what was specified on the CLI.
@param waitBlock until a client has connected. Defaults to what was specified on the CLI.
@returnsDisposable that calls
inspector.close(). Return the URL of the active inspector, or
undefinedif there is none.$ node --inspect -p 'inspector.url()' Debugger listening on ws://127.0.0.1:9229/166e272e-7a30-4d09-97ce-f1c012b43c34 For help, see: https://nodejs.org/en/docs/inspector ws://127.0.0.1:9229/166e272e-7a30-4d09-97ce-f1c012b43c34 $ node --inspect=localhost:3000 -p 'inspector.url()' Debugger listening on ws://localhost:3000/51cf8d0e-3c36-4c59-8efd-54519839e56a For help, see: https://nodejs.org/en/docs/inspector ws://localhost:3000/51cf8d0e-3c36-4c59-8efd-54519839e56a $ node -p 'inspector.url()' undefinedBlocks until a client (existing or connected later) has sent
Runtime.runIfWaitingForDebuggercommand.An exception will be thrown if there is no active inspector.
Type definitions
namespace Console
interface MessageAddedEventDataType
namespace Debugger
interface BreakLocation
interface BreakpointResolvedEventDataType
interface CallFrame
JavaScript call frame. Array of call frames form the call stack.
- callFrameId: string
Call frame identifier. This identifier is only valid while the virtual machine is paused.
interface ContinueToLocationParameterType
interface EnableReturnType
interface EvaluateOnCallFrameParameterType
- includeCommandLineAPI?: boolean
Specifies whether command line API should be available to the evaluated expression, defaults to false.
- objectGroup?: string
String object group name to put result into (allows rapid releasing resulting object handles using <code>releaseObjectGroup</code>).
- returnByValue?: boolean
Whether the result is expected to be a JSON object that should be sent by value.
- silent?: boolean
In silent mode exceptions thrown during evaluation are not reported and do not pause execution. Overrides <code>setPauseOnException</code> state.
- throwOnSideEffect?: boolean
Whether to throw an exception if side effect cannot be ruled out during evaluation.
interface EvaluateOnCallFrameReturnType
interface GetPossibleBreakpointsParameterType
- restrictToFunction?: boolean
Only consider locations which are in the same (non-nested) function as start.
interface GetPossibleBreakpointsReturnType
interface GetScriptSourceParameterType
interface GetScriptSourceReturnType
interface GetStackTraceReturnType
interface PausedEventDataType
- asyncCallStackTraceId?: StackTraceId
Just scheduled async call will have this stack trace as parent stack during async execution. This field is available only after <code>Debugger.stepInto</code> call with <code>breakOnAsynCall</code> flag.
interface PauseOnAsyncCallParameterType
- parentStackTraceId: StackTraceId
Debugger will pause when async call with given stack trace is started.
interface RemoveBreakpointParameterType
interface RestartFrameParameterType
interface RestartFrameReturnType
interface Scope
Scope description.
- object: RemoteObject
Object representing the scope. For <code>global</code> and <code>with</code> scopes it represents the actual object; for the rest of the scopes, it is artificial transient object enumerating scope variables as its properties.
interface ScriptFailedToParseEventDataType
- stackTrace?: StackTrace
JavaScript top stack frame of where the script parsed event was triggered if available.
interface ScriptParsedEventDataType
- stackTrace?: StackTrace
JavaScript top stack frame of where the script parsed event was triggered if available.
interface SearchInContentParameterType
interface SearchInContentReturnType
interface SetAsyncCallStackDepthParameterType
- maxDepth: number
Maximum depth of async call stacks. Setting to <code>0</code> will effectively disable collecting async call stacks (default).
interface SetBlackboxedRangesParameterType
interface SetBlackboxPatternsParameterType
interface SetBreakpointByUrlParameterType
- condition?: string
Expression to use as a breakpoint condition. When specified, debugger will only stop on the breakpoint if this expression evaluates to true.
- urlRegex?: string
Regex pattern for the URLs of the resources to set breakpoints on. Either <code>url</code> or <code>urlRegex</code> must be specified.
interface SetBreakpointByUrlReturnType
interface SetBreakpointParameterType
- condition?: string
Expression to use as a breakpoint condition. When specified, debugger will only stop on the breakpoint if this expression evaluates to true.
interface SetBreakpointReturnType
interface SetBreakpointsActiveParameterType
interface SetPauseOnExceptionsParameterType
interface SetReturnValueParameterType
interface SetScriptSourceParameterType
- dryRun?: boolean
If true the change will not actually be applied. Dry run may be used to get result description without actually modifying the code.
interface SetScriptSourceReturnType
interface SetSkipAllPausesParameterType
interface SetVariableValueParameterType
- scopeNumber: number
0-based number of scope as was listed in scope chain. Only 'local', 'closure' and 'catch' scope types are allowed. Other scopes could be manipulated manually.
interface StepIntoParameterType
- breakOnAsyncCall?: boolean
Debugger will issue additional Debugger.paused notification if any async task is scheduled before next pause.
- type BreakpointId = string
Breakpoint identifier.
- type CallFrameId = string
Call frame identifier.
namespace HeapProfiler
interface AddHeapSnapshotChunkEventDataType
interface AddInspectedHeapObjectParameterType
interface GetHeapObjectIdParameterType
interface GetHeapObjectIdReturnType
- heapSnapshotObjectId: string
Id of the heap snapshot object corresponding to the passed remote object id.
interface GetObjectByHeapObjectIdParameterType
interface GetObjectByHeapObjectIdReturnType
interface GetSamplingProfileReturnType
interface HeapStatsUpdateEventDataType
- statsUpdate: number[]
An array of triplets. Each triplet describes a fragment. The first integer is the fragment index, the second integer is a total count of objects for the fragment, the third integer is a total size of the objects for the fragment.
interface LastSeenObjectIdEventDataType
interface ReportHeapSnapshotProgressEventDataType
interface SamplingHeapProfileNode
Sampling Heap Profile node. Holds callsite information, allocation statistics and child nodes.
interface StartSamplingParameterType
- samplingInterval?: number
Average sample interval in bytes. Poisson distribution is used for the intervals. The default value is 32768 bytes.
interface StartTrackingHeapObjectsParameterType
interface StopSamplingReturnType
interface StopTrackingHeapObjectsParameterType
- reportProgress?: boolean
If true 'reportHeapSnapshotProgress' events will be generated while snapshot is being taken when the tracking is stopped.
interface TakeHeapSnapshotParameterType
- reportProgress?: boolean
If true 'reportHeapSnapshotProgress' events will be generated while snapshot is being taken.
- type HeapSnapshotObjectId = string
Heap snapshot object id.
namespace IO
interface CloseParameterType
interface ReadParameterType
- offset?: number
Seek to the specified offset before reading (if not specified, proceed with offset following the last read). Some types of streams may only support sequential reads.
interface ReadReturnType
- type StreamHandle = string
namespace NodeRuntime
namespace NodeTracing
interface DataCollectedEventDataType
interface GetCategoriesReturnType
interface StartParameterType
interface TraceConfig
namespace NodeWorker
interface AttachedToWorkerEventDataType
interface DetachedFromWorkerEventDataType
interface DetachParameterType
interface EnableParameterType
- waitForDebuggerOnStart: boolean
Whether to new workers should be paused until the frontend sends
Runtime.runIfWaitingForDebuggermessage to run them.
interface ReceivedMessageFromWorkerEventDataType
interface SendMessageToWorkerParameterType
interface WorkerInfo
- type SessionID = string
Unique identifier of attached debugging session.
- type WorkerID = string
namespace Profiler
interface ConsoleProfileStartedEventDataType
interface GetBestEffortCoverageReturnType
interface Profile
Profile.
- timeDeltas?: number[]
Time intervals between adjacent samples in microseconds. The first delta is relative to the profile startTime.
interface ProfileNode
Profile node. Holds callsite information, execution statistics and child nodes.
- deoptReason?: string
The reason of being not optimized. The function may be deoptimized or marked as don't optimize.
interface SetSamplingIntervalParameterType
interface StartPreciseCoverageParameterType
interface StopReturnType
interface TakePreciseCoverageReturnType
namespace Runtime
interface AwaitPromiseParameterType
- returnByValue?: boolean
Whether the result is expected to be a JSON object that should be sent by value.
interface AwaitPromiseReturnType
interface CallArgument
Represents function call argument. Either remote object id <code>objectId</code>, primitive <code>value</code>, unserializable primitive value or neither of (for undefined) them should be specified.
interface CallFunctionOnParameterType
- arguments?: CallArgument[]
Call arguments. All call arguments must belong to the same JavaScript world as the target object.
- awaitPromise?: boolean
Whether execution should <code>await</code> for resulting value and return once awaited promise is resolved.
- executionContextId?: number
Specifies execution context which global object will be used to call function on. Either executionContextId or objectId should be specified.
- objectGroup?: string
Symbolic group name that can be used to release multiple objects. If objectGroup is not specified and objectId is, objectGroup will be inherited from object.
- objectId?: string
Identifier of the object to call function on. Either objectId or executionContextId should be specified.
- returnByValue?: boolean
Whether the result is expected to be a JSON object which should be sent by value.
- silent?: boolean
In silent mode exceptions thrown during evaluation are not reported and do not pause execution. Overrides <code>setPauseOnException</code> state.
interface CallFunctionOnReturnType
interface CompileScriptParameterType
- executionContextId?: number
Specifies in which execution context to perform script run. If the parameter is omitted the evaluation will be performed in the context of the inspected page.
interface CompileScriptReturnType
interface ConsoleAPICalledEventDataType
- context?: string
Console context descriptor for calls on non-default console context (not console.*): 'anonymous#unique-logger-id' for call on unnamed context, 'name#unique-logger-id' for call on named context.
interface EvaluateParameterType
- awaitPromise?: boolean
Whether execution should <code>await</code> for resulting value and return once awaited promise is resolved.
- contextId?: number
Specifies in which execution context to perform evaluation. If the parameter is omitted the evaluation will be performed in the context of the inspected page.
- includeCommandLineAPI?: boolean
Determines whether Command Line API should be available during the evaluation.
- returnByValue?: boolean
Whether the result is expected to be a JSON object that should be sent by value.
- silent?: boolean
In silent mode exceptions thrown during evaluation are not reported and do not pause execution. Overrides <code>setPauseOnException</code> state.
interface EvaluateReturnType
interface ExceptionDetails
Detailed information about exception (or error) that was thrown during script compilation or execution.
interface ExceptionRevokedEventDataType
interface ExceptionThrownEventDataType
interface ExecutionContextCreatedEventDataType
interface ExecutionContextDescription
Description of an isolated world.
- id: number
Unique id of the execution context. It can be used to specify in which execution context script evaluation should be performed.
interface ExecutionContextDestroyedEventDataType
interface GetPropertiesParameterType
- accessorPropertiesOnly?: boolean
If true, returns accessor properties (with getter/setter) only; internal properties are not returned either.
- ownProperties?: boolean
If true, returns properties belonging only to the element itself, not to its prototype chain.
interface GetPropertiesReturnType
- internalProperties?: InternalPropertyDescriptor[]
Internal object properties (only of the element itself).
interface GlobalLexicalScopeNamesParameterType
interface GlobalLexicalScopeNamesReturnType
interface InspectRequestedEventDataType
interface InternalPropertyDescriptor
Object internal property descriptor. This property isn't normally visible in JavaScript code.
interface ObjectPreview
Object containing abbreviated remote object value.
- entries?: EntryPreview[]
List of the entries. Specified for <code>map</code> and <code>set</code> subtype values only.
interface PropertyDescriptor
Object property descriptor.
- configurable: boolean
True if the type of this property descriptor may be changed and if the property may be deleted from the corresponding object.
- enumerable: boolean
True if this property shows up during enumeration of the properties on the corresponding object.
- get?: RemoteObject
A function which serves as a getter for the property, or <code>undefined</code> if there is no getter (accessor descriptors only).
- set?: RemoteObject
A function which serves as a setter for the property, or <code>undefined</code> if there is no setter (accessor descriptors only).
- writable?: boolean
True if the value associated with the property may be changed (data descriptors only).
interface QueryObjectsParameterType
interface QueryObjectsReturnType
interface ReleaseObjectGroupParameterType
interface ReleaseObjectParameterType
interface RemoteObject
Mirror object referencing original JavaScript object.
- className?: string
Object class (constructor) name. Specified for <code>object</code> type values only.
- preview?: ObjectPreview
Preview containing abbreviated property values. Specified for <code>object</code> type values only.
- unserializableValue?: string
Primitive value which can not be JSON-stringified does not have <code>value</code>, but gets this property.
interface RunScriptParameterType
- awaitPromise?: boolean
Whether execution should <code>await</code> for resulting value and return once awaited promise is resolved.
- executionContextId?: number
Specifies in which execution context to perform script run. If the parameter is omitted the evaluation will be performed in the context of the inspected page.
- includeCommandLineAPI?: boolean
Determines whether Command Line API should be available during the evaluation.
- returnByValue?: boolean
Whether the result is expected to be a JSON object which should be sent by value.
- silent?: boolean
In silent mode exceptions thrown during evaluation are not reported and do not pause execution. Overrides <code>setPauseOnException</code> state.
interface RunScriptReturnType
interface StackTrace
Call frames for assertions or error messages.
- description?: string
String label of this stack trace. For async traces this may be a name of the function that initiated the async call.
interface StackTraceId
If <code>debuggerId</code> is set stack trace comes from another debugger and can be resolved there. This allows to track cross-debugger calls. See <code>Runtime.StackTrace</code> and <code>Debugger.paused</code> for usages.
- type ExecutionContextId = number
Id of an execution context.
- type RemoteObjectId = string
Unique object identifier.
- type ScriptId = string
Unique script identifier.
- type Timestamp = number
Number of milliseconds since epoch.
- type UniqueDebuggerId = string
Unique identifier of current debugger.
- type UnserializableValue = string
Primitive value which cannot be JSON-stringified.
namespace Target
interface AttachedToTargetEventDataType
interface SetAutoAttachParameterType
interface TargetCreatedEventDataType
interface TargetInfo
- type SessionID = string
- type TargetID = string
interface InspectorConsole
interface InspectorNotification<T>