v8.d.ts (27413B)
1 /** 2 * The `node:v8` module exposes APIs that are specific to the version of [V8](https://developers.google.com/v8/) built into the Node.js binary. It can be accessed using: 3 * 4 * ```js 5 * import v8 from 'node:v8'; 6 * ``` 7 * @see [source](https://github.com/nodejs/node/blob/v16.20.2/lib/v8.js) 8 */ 9 declare module "v8" { 10 import { Readable } from "node:stream"; 11 interface HeapSpaceInfo { 12 space_name: string; 13 space_size: number; 14 space_used_size: number; 15 space_available_size: number; 16 physical_space_size: number; 17 } 18 // ** Signifies if the --zap_code_space option is enabled or not. 1 == enabled, 0 == disabled. */ 19 type DoesZapCodeSpaceFlag = 0 | 1; 20 interface HeapInfo { 21 total_heap_size: number; 22 total_heap_size_executable: number; 23 total_physical_size: number; 24 total_available_size: number; 25 used_heap_size: number; 26 heap_size_limit: number; 27 malloced_memory: number; 28 peak_malloced_memory: number; 29 does_zap_garbage: DoesZapCodeSpaceFlag; 30 number_of_native_contexts: number; 31 number_of_detached_contexts: number; 32 total_global_handles_size: number; 33 used_global_handles_size: number; 34 external_memory: number; 35 } 36 interface HeapCodeStatistics { 37 code_and_metadata_size: number; 38 bytecode_and_metadata_size: number; 39 external_script_source_size: number; 40 } 41 /** 42 * Returns an integer representing a version tag derived from the V8 version, 43 * command-line flags, and detected CPU features. This is useful for determining 44 * whether a `vm.Script` `cachedData` buffer is compatible with this instance 45 * of V8. 46 * 47 * ```js 48 * console.log(v8.cachedDataVersionTag()); // 3947234607 49 * // The value returned by v8.cachedDataVersionTag() is derived from the V8 50 * // version, command-line flags, and detected CPU features. Test that the value 51 * // does indeed update when flags are toggled. 52 * v8.setFlagsFromString('--allow_natives_syntax'); 53 * console.log(v8.cachedDataVersionTag()); // 183726201 54 * ``` 55 * @since v8.0.0 56 */ 57 function cachedDataVersionTag(): number; 58 /** 59 * Returns an object with the following properties: 60 * 61 * `does_zap_garbage` is a 0/1 boolean, which signifies whether the`--zap_code_space` option is enabled or not. This makes V8 overwrite heap 62 * garbage with a bit pattern. The RSS footprint (resident set size) gets bigger 63 * because it continuously touches all heap pages and that makes them less likely 64 * to get swapped out by the operating system. 65 * 66 * `number_of_native_contexts` The value of native\_context is the number of the 67 * top-level contexts currently active. Increase of this number over time indicates 68 * a memory leak. 69 * 70 * `number_of_detached_contexts` The value of detached\_context is the number 71 * of contexts that were detached and not yet garbage collected. This number 72 * being non-zero indicates a potential memory leak. 73 * 74 * `total_global_handles_size` The value of total\_global\_handles\_size is the 75 * total memory size of V8 global handles. 76 * 77 * `used_global_handles_size` The value of used\_global\_handles\_size is the 78 * used memory size of V8 global handles. 79 * 80 * `external_memory` The value of external\_memory is the memory size of array 81 * buffers and external strings. 82 * 83 * ```js 84 * { 85 * total_heap_size: 7326976, 86 * total_heap_size_executable: 4194304, 87 * total_physical_size: 7326976, 88 * total_available_size: 1152656, 89 * used_heap_size: 3476208, 90 * heap_size_limit: 1535115264, 91 * malloced_memory: 16384, 92 * peak_malloced_memory: 1127496, 93 * does_zap_garbage: 0, 94 * number_of_native_contexts: 1, 95 * number_of_detached_contexts: 0, 96 * total_global_handles_size: 8192, 97 * used_global_handles_size: 3296, 98 * external_memory: 318824 99 * } 100 * ``` 101 * @since v1.0.0 102 */ 103 function getHeapStatistics(): HeapInfo; 104 /** 105 * Returns statistics about the V8 heap spaces, i.e. the segments which make up 106 * the V8 heap. Neither the ordering of heap spaces, nor the availability of a 107 * heap space can be guaranteed as the statistics are provided via the 108 * V8 [`GetHeapSpaceStatistics`](https://v8docs.nodesource.com/node-13.2/d5/dda/classv8_1_1_isolate.html#ac673576f24fdc7a33378f8f57e1d13a4) function and may change from one V8 version to the 109 * next. 110 * 111 * The value returned is an array of objects containing the following properties: 112 * 113 * ```json 114 * [ 115 * { 116 * "space_name": "new_space", 117 * "space_size": 2063872, 118 * "space_used_size": 951112, 119 * "space_available_size": 80824, 120 * "physical_space_size": 2063872 121 * }, 122 * { 123 * "space_name": "old_space", 124 * "space_size": 3090560, 125 * "space_used_size": 2493792, 126 * "space_available_size": 0, 127 * "physical_space_size": 3090560 128 * }, 129 * { 130 * "space_name": "code_space", 131 * "space_size": 1260160, 132 * "space_used_size": 644256, 133 * "space_available_size": 960, 134 * "physical_space_size": 1260160 135 * }, 136 * { 137 * "space_name": "map_space", 138 * "space_size": 1094160, 139 * "space_used_size": 201608, 140 * "space_available_size": 0, 141 * "physical_space_size": 1094160 142 * }, 143 * { 144 * "space_name": "large_object_space", 145 * "space_size": 0, 146 * "space_used_size": 0, 147 * "space_available_size": 1490980608, 148 * "physical_space_size": 0 149 * } 150 * ] 151 * ``` 152 * @since v6.0.0 153 */ 154 function getHeapSpaceStatistics(): HeapSpaceInfo[]; 155 /** 156 * The `v8.setFlagsFromString()` method can be used to programmatically set 157 * V8 command-line flags. This method should be used with care. Changing settings 158 * after the VM has started may result in unpredictable behavior, including 159 * crashes and data loss; or it may simply do nothing. 160 * 161 * The V8 options available for a version of Node.js may be determined by running`node --v8-options`. 162 * 163 * Usage: 164 * 165 * ```js 166 * // Print GC events to stdout for one minute. 167 * import v8 from 'node:v8'; 168 * v8.setFlagsFromString('--trace_gc'); 169 * setTimeout(() => { v8.setFlagsFromString('--notrace_gc'); }, 60e3); 170 * ``` 171 * @since v1.0.0 172 */ 173 function setFlagsFromString(flags: string): void; 174 /** 175 * Generates a snapshot of the current V8 heap and returns a Readable 176 * Stream that may be used to read the JSON serialized representation. 177 * This JSON stream format is intended to be used with tools such as 178 * Chrome DevTools. The JSON schema is undocumented and specific to the 179 * V8 engine. Therefore, the schema may change from one version of V8 to the next. 180 * 181 * Creating a heap snapshot requires memory about twice the size of the heap at 182 * the time the snapshot is created. This results in the risk of OOM killers 183 * terminating the process. 184 * 185 * Generating a snapshot is a synchronous operation which blocks the event loop 186 * for a duration depending on the heap size. 187 * 188 * ```js 189 * // Print heap snapshot to the console 190 * import v8 from 'node:v8'; 191 * const stream = v8.getHeapSnapshot(); 192 * stream.pipe(process.stdout); 193 * ``` 194 * @since v11.13.0 195 * @return A Readable Stream containing the V8 heap snapshot 196 */ 197 function getHeapSnapshot(): Readable; 198 /** 199 * Generates a snapshot of the current V8 heap and writes it to a JSON 200 * file. This file is intended to be used with tools such as Chrome 201 * DevTools. The JSON schema is undocumented and specific to the V8 202 * engine, and may change from one version of V8 to the next. 203 * 204 * A heap snapshot is specific to a single V8 isolate. When using `worker threads`, a heap snapshot generated from the main thread will 205 * not contain any information about the workers, and vice versa. 206 * 207 * Creating a heap snapshot requires memory about twice the size of the heap at 208 * the time the snapshot is created. This results in the risk of OOM killers 209 * terminating the process. 210 * 211 * Generating a snapshot is a synchronous operation which blocks the event loop 212 * for a duration depending on the heap size. 213 * 214 * ```js 215 * import { writeHeapSnapshot } from 'node:v8'; 216 * import { 217 * Worker, 218 * isMainThread, 219 * parentPort, 220 * } from 'node:worker_threads'; 221 * 222 * if (isMainThread) { 223 * const worker = new Worker(__filename); 224 * 225 * worker.once('message', (filename) => { 226 * console.log(`worker heapdump: ${filename}`); 227 * // Now get a heapdump for the main thread. 228 * console.log(`main thread heapdump: ${writeHeapSnapshot()}`); 229 * }); 230 * 231 * // Tell the worker to create a heapdump. 232 * worker.postMessage('heapdump'); 233 * } else { 234 * parentPort.once('message', (message) => { 235 * if (message === 'heapdump') { 236 * // Generate a heapdump for the worker 237 * // and return the filename to the parent. 238 * parentPort.postMessage(writeHeapSnapshot()); 239 * } 240 * }); 241 * } 242 * ``` 243 * @since v11.13.0 244 * @param filename The file path where the V8 heap snapshot is to be saved. If not specified, a file name with the pattern `'Heap-${yyyymmdd}-${hhmmss}-${pid}-${thread_id}.heapsnapshot'` will be 245 * generated, where `{pid}` will be the PID of the Node.js process, `{thread_id}` will be `0` when `writeHeapSnapshot()` is called from the main Node.js thread or the id of a 246 * worker thread. 247 * @return The filename where the snapshot was saved. 248 */ 249 function writeHeapSnapshot(filename?: string): string; 250 /** 251 * Get statistics about code and its metadata in the heap, see 252 * V8 [`GetHeapCodeAndMetadataStatistics`](https://v8docs.nodesource.com/node-13.2/d5/dda/classv8_1_1_isolate.html#a6079122af17612ef54ef3348ce170866) API. Returns an object with the 253 * following properties: 254 * 255 * ```js 256 * { 257 * code_and_metadata_size: 212208, 258 * bytecode_and_metadata_size: 161368, 259 * external_script_source_size: 1410794, 260 * cpu_profiler_metadata_size: 0, 261 * } 262 * ``` 263 * @since v12.8.0 264 */ 265 function getHeapCodeStatistics(): HeapCodeStatistics; 266 /** 267 * @since v8.0.0 268 */ 269 class Serializer { 270 /** 271 * Writes out a header, which includes the serialization format version. 272 */ 273 writeHeader(): void; 274 /** 275 * Serializes a JavaScript value and adds the serialized representation to the 276 * internal buffer. 277 * 278 * This throws an error if `value` cannot be serialized. 279 */ 280 writeValue(val: any): boolean; 281 /** 282 * Returns the stored internal buffer. This serializer should not be used once 283 * the buffer is released. Calling this method results in undefined behavior 284 * if a previous write has failed. 285 */ 286 releaseBuffer(): Buffer; 287 /** 288 * Marks an `ArrayBuffer` as having its contents transferred out of band. 289 * Pass the corresponding `ArrayBuffer` in the deserializing context to `deserializer.transferArrayBuffer()`. 290 * @param id A 32-bit unsigned integer. 291 * @param arrayBuffer An `ArrayBuffer` instance. 292 */ 293 transferArrayBuffer(id: number, arrayBuffer: ArrayBuffer): void; 294 /** 295 * Write a raw 32-bit unsigned integer. 296 * For use inside of a custom `serializer._writeHostObject()`. 297 */ 298 writeUint32(value: number): void; 299 /** 300 * Write a raw 64-bit unsigned integer, split into high and low 32-bit parts. 301 * For use inside of a custom `serializer._writeHostObject()`. 302 */ 303 writeUint64(hi: number, lo: number): void; 304 /** 305 * Write a JS `number` value. 306 * For use inside of a custom `serializer._writeHostObject()`. 307 */ 308 writeDouble(value: number): void; 309 /** 310 * Write raw bytes into the serializer's internal buffer. The deserializer 311 * will require a way to compute the length of the buffer. 312 * For use inside of a custom `serializer._writeHostObject()`. 313 */ 314 writeRawBytes(buffer: NodeJS.TypedArray): void; 315 } 316 /** 317 * A subclass of `Serializer` that serializes `TypedArray`(in particular `Buffer`) and `DataView` objects as host objects, and only 318 * stores the part of their underlying `ArrayBuffer`s that they are referring to. 319 * @since v8.0.0 320 */ 321 class DefaultSerializer extends Serializer {} 322 /** 323 * @since v8.0.0 324 */ 325 class Deserializer { 326 constructor(data: NodeJS.TypedArray); 327 /** 328 * Reads and validates a header (including the format version). 329 * May, for example, reject an invalid or unsupported wire format. In that case, 330 * an `Error` is thrown. 331 */ 332 readHeader(): boolean; 333 /** 334 * Deserializes a JavaScript value from the buffer and returns it. 335 */ 336 readValue(): any; 337 /** 338 * Marks an `ArrayBuffer` as having its contents transferred out of band. 339 * Pass the corresponding `ArrayBuffer` in the serializing context to `serializer.transferArrayBuffer()` (or return the `id` from `serializer._getSharedArrayBufferId()` in the case of 340 * `SharedArrayBuffer`s). 341 * @param id A 32-bit unsigned integer. 342 * @param arrayBuffer An `ArrayBuffer` instance. 343 */ 344 transferArrayBuffer(id: number, arrayBuffer: ArrayBuffer): void; 345 /** 346 * Reads the underlying wire format version. Likely mostly to be useful to 347 * legacy code reading old wire format versions. May not be called before`.readHeader()`. 348 */ 349 getWireFormatVersion(): number; 350 /** 351 * Read a raw 32-bit unsigned integer and return it. 352 * For use inside of a custom `deserializer._readHostObject()`. 353 */ 354 readUint32(): number; 355 /** 356 * Read a raw 64-bit unsigned integer and return it as an array `[hi, lo]`with two 32-bit unsigned integer entries. 357 * For use inside of a custom `deserializer._readHostObject()`. 358 */ 359 readUint64(): [number, number]; 360 /** 361 * Read a JS `number` value. 362 * For use inside of a custom `deserializer._readHostObject()`. 363 */ 364 readDouble(): number; 365 /** 366 * Read raw bytes from the deserializer's internal buffer. The `length` parameter 367 * must correspond to the length of the buffer that was passed to `serializer.writeRawBytes()`. 368 * For use inside of a custom `deserializer._readHostObject()`. 369 */ 370 readRawBytes(length: number): Buffer; 371 } 372 /** 373 * A subclass of `Deserializer` corresponding to the format written by `DefaultSerializer`. 374 * @since v8.0.0 375 */ 376 class DefaultDeserializer extends Deserializer {} 377 /** 378 * Uses a `DefaultSerializer` to serialize `value` into a buffer. 379 * 380 * `ERR_BUFFER_TOO_LARGE` will be thrown when trying to 381 * serialize a huge object which requires buffer 382 * larger than `buffer.constants.MAX_LENGTH`. 383 * @since v8.0.0 384 */ 385 function serialize(value: any): Buffer; 386 /** 387 * Uses a `DefaultDeserializer` with default options to read a JS value 388 * from a buffer. 389 * @since v8.0.0 390 * @param buffer A buffer returned by {@link serialize}. 391 */ 392 function deserialize(buffer: NodeJS.ArrayBufferView): any; 393 /** 394 * The `v8.takeCoverage()` method allows the user to write the coverage started by `NODE_V8_COVERAGE` to disk on demand. This method can be invoked multiple 395 * times during the lifetime of the process. Each time the execution counter will 396 * be reset and a new coverage report will be written to the directory specified 397 * by `NODE_V8_COVERAGE`. 398 * 399 * When the process is about to exit, one last coverage will still be written to 400 * disk unless {@link stopCoverage} is invoked before the process exits. 401 * @since v15.1.0, v14.18.0, v12.22.0 402 */ 403 function takeCoverage(): void; 404 /** 405 * The `v8.stopCoverage()` method allows the user to stop the coverage collection 406 * started by `NODE_V8_COVERAGE`, so that V8 can release the execution count 407 * records and optimize code. This can be used in conjunction with {@link takeCoverage} if the user wants to collect the coverage on demand. 408 * @since v15.1.0, v14.18.0, v12.22.0 409 */ 410 function stopCoverage(): void; 411 /** 412 * The API is a no-op if `--heapsnapshot-near-heap-limit` is already set from the command line or the API is called more than once. 413 * `limit` must be a positive integer. See [`--heapsnapshot-near-heap-limit`](https://nodejs.org/docs/latest-v16.x/api/cli.html#--heapsnapshot-near-heap-limitmax_count) for more information. 414 * @experimental 415 * @since v16.18.0 416 */ 417 function setHeapSnapshotNearHeapLimit(limit: number): void; 418 /** 419 * Called when a promise is constructed. This does not mean that corresponding before/after events will occur, only that the possibility exists. This will 420 * happen if a promise is created without ever getting a continuation. 421 * @since v16.14.0 422 * @param promise The promise being created. 423 * @param parent The promise continued from, if applicable. 424 */ 425 interface Init { 426 (promise: Promise<unknown>, parent: Promise<unknown>): void; 427 } 428 /** 429 * Called before a promise continuation executes. This can be in the form of `then()`, `catch()`, or `finally()` handlers or an await resuming. 430 * 431 * The before callback will be called 0 to N times. The before callback will typically be called 0 times if no continuation was ever made for the promise. 432 * The before callback may be called many times in the case where many continuations have been made from the same promise. 433 * @since v16.14.0 434 */ 435 interface Before { 436 (promise: Promise<unknown>): void; 437 } 438 /** 439 * Called immediately after a promise continuation executes. This may be after a `then()`, `catch()`, or `finally()` handler or before an await after another await. 440 * @since v16.14.0 441 */ 442 interface After { 443 (promise: Promise<unknown>): void; 444 } 445 /** 446 * Called when the promise receives a resolution or rejection value. This may occur synchronously in the case of {@link Promise.resolve()} or 447 * {@link Promise.reject()}. 448 * @since v16.14.0 449 */ 450 interface Settled { 451 (promise: Promise<unknown>): void; 452 } 453 /** 454 * Key events in the lifetime of a promise have been categorized into four areas: creation of a promise, before/after a continuation handler is called or 455 * around an await, and when the promise resolves or rejects. 456 * 457 * Because promises are asynchronous resources whose lifecycle is tracked via the promise hooks mechanism, the `init()`, `before()`, `after()`, and 458 * `settled()` callbacks must not be async functions as they create more promises which would produce an infinite loop. 459 * @since v16.14.0 460 */ 461 interface HookCallbacks { 462 init?: Init; 463 before?: Before; 464 after?: After; 465 settled?: Settled; 466 } 467 interface PromiseHooks { 468 /** 469 * The `init` hook must be a plain function. Providing an async function will throw as it would produce an infinite microtask loop. 470 * @since v16.14.0 471 * @param init The {@link Init | `init` callback} to call when a promise is created. 472 * @return Call to stop the hook. 473 */ 474 onInit: (init: Init) => Function; 475 /** 476 * The `settled` hook must be a plain function. Providing an async function will throw as it would produce an infinite microtask loop. 477 * @since v16.14.0 478 * @param settled The {@link Settled | `settled` callback} to call when a promise is created. 479 * @return Call to stop the hook. 480 */ 481 onSettled: (settled: Settled) => Function; 482 /** 483 * The `before` hook must be a plain function. Providing an async function will throw as it would produce an infinite microtask loop. 484 * @since v16.14.0 485 * @param before The {@link Before | `before` callback} to call before a promise continuation executes. 486 * @return Call to stop the hook. 487 */ 488 onBefore: (before: Before) => Function; 489 /** 490 * The `after` hook must be a plain function. Providing an async function will throw as it would produce an infinite microtask loop. 491 * @since v16.14.0 492 * @param after The {@link After | `after` callback} to call after a promise continuation executes. 493 * @return Call to stop the hook. 494 */ 495 onAfter: (after: After) => Function; 496 /** 497 * Registers functions to be called for different lifetime events of each promise. 498 * The callbacks `init()`/`before()`/`after()`/`settled()` are called for the respective events during a promise's lifetime. 499 * All callbacks are optional. For example, if only promise creation needs to be tracked, then only the init callback needs to be passed. 500 * The hook callbacks must be plain functions. Providing async functions will throw as it would produce an infinite microtask loop. 501 * @since v16.14.0 502 * @param callbacks The {@link HookCallbacks | Hook Callbacks} to register 503 * @return Used for disabling hooks 504 */ 505 createHook: (callbacks: HookCallbacks) => Function; 506 } 507 /** 508 * The `promiseHooks` interface can be used to track promise lifecycle events. 509 * @since v16.14.0 510 */ 511 const promiseHooks: PromiseHooks; 512 type StartupSnapshotCallbackFn = (args: any) => any; 513 interface StartupSnapshot { 514 /** 515 * Add a callback that will be called when the Node.js instance is about to get serialized into a snapshot and exit. 516 * This can be used to release resources that should not or cannot be serialized or to convert user data into a form more suitable for serialization. 517 * @since v16.17.0 518 */ 519 addSerializeCallback(callback: StartupSnapshotCallbackFn, data?: any): void; 520 /** 521 * Add a callback that will be called when the Node.js instance is deserialized from a snapshot. 522 * The `callback` and the `data` (if provided) will be serialized into the snapshot, they can be used to re-initialize the state of the application or 523 * to re-acquire resources that the application needs when the application is restarted from the snapshot. 524 * @since v16.17.0 525 */ 526 addDeserializeCallback(callback: StartupSnapshotCallbackFn, data?: any): void; 527 /** 528 * This sets the entry point of the Node.js application when it is deserialized from a snapshot. This can be called only once in the snapshot building script. 529 * If called, the deserialized application no longer needs an additional entry point script to start up and will simply invoke the callback along with the deserialized 530 * data (if provided), otherwise an entry point script still needs to be provided to the deserialized application. 531 * @since v16.17.0 532 */ 533 setDeserializeMainFunction(callback: StartupSnapshotCallbackFn, data?: any): void; 534 /** 535 * Returns true if the Node.js instance is run to build a snapshot. 536 * @since v16.17.0 537 */ 538 isBuildingSnapshot(): boolean; 539 } 540 /** 541 * The `v8.startupSnapshot` interface can be used to add serialization and deserialization hooks for custom startup snapshots. 542 * 543 * ```bash 544 * $ node --snapshot-blob snapshot.blob --build-snapshot entry.js 545 * # This launches a process with the snapshot 546 * $ node --snapshot-blob snapshot.blob 547 * ``` 548 * 549 * In the example above, `entry.js` can use methods from the `v8.startupSnapshot` interface to specify how to save information for custom objects 550 * in the snapshot during serialization 551 * and how the information can be used to synchronize these objects during deserialization of the snapshot. 552 * For example, if the `entry.js` contains the following script: 553 * 554 * ```js 555 * 'use strict'; 556 * 557 * import fs from 'node:fs'; 558 * import zlib from 'node:zlib'; 559 * import path from 'node:path'; 560 * import assert from 'node:assert'; 561 * 562 * import v8 from 'node:v8'; 563 * 564 * class BookShelf { 565 * storage = new Map(); 566 * 567 * // Reading a series of files from directory and store them into storage. 568 * constructor(directory, books) { 569 * for (const book of books) { 570 * this.storage.set(book, fs.readFileSync(path.join(directory, book))); 571 * } 572 * } 573 * 574 * static compressAll(shelf) { 575 * for (const [ book, content ] of shelf.storage) { 576 * shelf.storage.set(book, zlib.gzipSync(content)); 577 * } 578 * } 579 * 580 * static decompressAll(shelf) { 581 * for (const [ book, content ] of shelf.storage) { 582 * shelf.storage.set(book, zlib.gunzipSync(content)); 583 * } 584 * } 585 * } 586 * 587 * // __dirname here is where the snapshot script is placed 588 * // during snapshot building time. 589 * const shelf = new BookShelf(__dirname, [ 590 * 'book1.en_US.txt', 591 * 'book1.es_ES.txt', 592 * 'book2.zh_CN.txt', 593 * ]); 594 * 595 * assert(v8.startupSnapshot.isBuildingSnapshot()); 596 * // On snapshot serialization, compress the books to reduce size. 597 * v8.startupSnapshot.addSerializeCallback(BookShelf.compressAll, shelf); 598 * // On snapshot deserialization, decompress the books. 599 * v8.startupSnapshot.addDeserializeCallback(BookShelf.decompressAll, shelf); 600 * v8.startupSnapshot.setDeserializeMainFunction((shelf) => { 601 * // process.env and process.argv are refreshed during snapshot 602 * // deserialization. 603 * const lang = process.env.BOOK_LANG || 'en_US'; 604 * const book = process.argv[1]; 605 * const name = `${book}.${lang}.txt`; 606 * console.log(shelf.storage.get(name)); 607 * }, shelf); 608 * ``` 609 * 610 * The resulted binary will get print the data deserialized from the snapshot during start up, using the refreshed `process.env` and `process.argv` of the launched process: 611 * 612 * ```bash 613 * $ BOOK_LANG=es_ES node --snapshot-blob snapshot.blob book1 614 * # Prints content of book1.es_ES.txt deserialized from the snapshot. 615 * ``` 616 * 617 * Currently the application deserialized from a user-land snapshot cannot be snapshotted again, so these APIs are only available to applications that are not deserialized from a user-land snapshot. 618 * 619 * @experimental 620 * @since v16.17.0 621 */ 622 const startupSnapshot: StartupSnapshot; 623 } 624 declare module "node:v8" { 625 export * from "v8"; 626 }