Repository navigation
Update recorder to the version free of OpenSSL dependency - #123
Merged
Merged
Conversation
bhackett1024
approved these changes
Apr 16, 2026
bhackett1024
added a commit
that referenced
this pull request
Nov 5, 2026
Add src/node_recordreplay.cc with Replay's node integration: loading the driver (InitializeRecordReplay and OpenDriverHandle, from RECORD_REPLAY_DRIVER or the copy embedded in the binary), the symbol table of driver function pointers, attaching the recorder with the build ID, recording the command line arguments and the argv metadata, and RecordReplayFinishRecording, which appends the recording ID to RECORD_REPLAY_RECORDING_ID_FILE unless the recording is unusable. The node::recordreplay namespace holds the helpers the rest of node uses: callback region scopes, whether the recording has finished, whether a call is inside a callback the driver intercepts, whether events are available (recording or replaying, with events neither disallowed nor passed through and no divergence) or recorded, and ThrowIfEventsUnavailable, which makes an operation that cannot be replayed throw instead of running unrecorded. Expose the recording primitives to JavaScript as process binding methods: RecordReplayLog, the CDP message pair (a callback for responses and events, and sending a message through a process-owned inspector session), the annotation hook, assertions, script ignoring, the recording ID, the current execution point and elapsed time, and the external references for all of them. Replay's own session connects, dispatches and delivers messages to the frontend as replay code with events disallowed, so none of that work can diverge, and the session is reset from AtExit, where node normally waits for external debugger frontends to disconnect: process.exit() skips Environment destruction, so the session would otherwise survive until static destruction, after V8's platform has been disposed. That also disables the debugger, which leaves WebAssembly modules tiered down (see V8Debugger::disable). In node.cc, initialize record/replay and mark the sibling group map ordered before anything else, apply the old space limit the driver asks for (REPLAY_RECORD_MAX_OLD_SPACE_MB / REPLAY_REPLAY_MAX_OLD_SPACE_MB, read through RecordReplayMaxOldSpaceMb) as a V8 flag after the command line's, so that the arguments and process.execArgv stay the same when replaying, print the build ID and exit for --print-build-id, create the first checkpoint on the main thread before the entry script runs, and leave V8's WebAssembly trap handler disabled while recording/replaying, so V8 keeps emitting bounds checks instead of relying on a SIGSEGV the recorder treats as a crash. Rebase note: nearly all of this is new code in src/node_recordreplay.cc, so conflicts should only come from the call sites, which are one line each. InitializeRecordReplay() must run early in InitializeOncePerProcess, before V8, OpenSSL and the platform are initialized, and the driver's old space limit is applied after node has processed the command line's V8 options, so that it wins. The --print-build-id early return sits with the other print-and-exit options, and StartExecution creates a checkpoint on the main thread before running the entry script. The process methods are only added to the process_methods binding, so upstream changes to how bindings register methods (for example env->SetMethod(target, ...) becoming SetMethod(context, target, ...) in later v16 releases) must be applied to these registrations too, and the method names must stay in sync with lib/internal/bootstrap/node.js. Includes later changes from #123, #130, #151, #155, #164, #166, #167, Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
added a commit
that referenced
this pull request
Nov 6, 2026
Add build.js script for downloading the Replay driver and compiling Node.js, REPLAY_BACKEND_REV for version tracking, .gitignore updates, and node.gyp change to include node_record_replay_driver.cc. build.js can use a local driver (REPLAY_LOCAL_DRIVER_DIR), builds into out/, strips Nix paths from the build environment, and only rewrites node_record_replay_driver.cc when its contents change, so make does not rebuild the embedded driver needlessly. Includes later changes from #123, #124, #125, #127, #128, #132, #136, #147, #172, #185, #186, #198, #200, #219, #221, #225 and #227. Co-authored-by: Domi <Domiii@users.noreply.github.com> Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
added a commit
that referenced
this pull request
Nov 6, 2026
Add src/node_recordreplay.cc with Replay's node integration: loading the driver (InitializeRecordReplay and OpenDriverHandle, from RECORD_REPLAY_DRIVER or the copy embedded in the binary), the symbol table of driver function pointers, attaching the recorder with the build ID, recording the command line arguments and the argv metadata, and RecordReplayFinishRecording, which appends the recording ID to RECORD_REPLAY_RECORDING_ID_FILE unless the recording is unusable. The node::recordreplay namespace holds the helpers the rest of node uses: callback region scopes, whether the recording has finished, whether a call is inside a callback the driver intercepts, whether events are available (recording or replaying, with events neither disallowed nor passed through and no divergence) or recorded, and ThrowIfEventsUnavailable, which makes an operation that cannot be replayed throw instead of running unrecorded. Expose the recording primitives to JavaScript as process binding methods: RecordReplayLog, the CDP message pair (a callback for responses and events, and sending a message through a process-owned inspector session), the annotation hook, assertions, script ignoring, the recording ID, the current execution point and elapsed time, and the external references for all of them. Replay's own session connects, dispatches and delivers messages to the frontend as replay code with events disallowed, so none of that work can diverge, and the session is reset from AtExit, where node normally waits for external debugger frontends to disconnect: process.exit() skips Environment destruction, so the session would otherwise survive until static destruction, after V8's platform has been disposed. That also disables the debugger, which leaves WebAssembly modules tiered down (see V8Debugger::disable). In node.cc, initialize record/replay and mark the sibling group map ordered before anything else, apply the old space limit the driver asks for (REPLAY_RECORD_MAX_OLD_SPACE_MB / REPLAY_REPLAY_MAX_OLD_SPACE_MB, read through RecordReplayMaxOldSpaceMb) as a V8 flag after the command line's, so that the arguments and process.execArgv stay the same when replaying, print the build ID and exit for --print-build-id, create the first checkpoint on the main thread before the entry script runs, and leave V8's WebAssembly trap handler disabled while recording/replaying, so V8 keeps emitting bounds checks instead of relying on a SIGSEGV the recorder treats as a crash. libuv keeps a pointer into argv for the process title rather than copying it, so whichever argv uv_setup_args() sees decides the title. Start() calls it before InitializeOncePerProcess(), where the driver replaces the arguments with the recording's, so a replay reported its own argv[0] instead. Node sends that title to a debugger frontend as the execution context's name, where it diverged from the recording's and the write to the frontend's socket was a different length, so the replay sets the arguments up again once the driver has installed them. Rebase note: nearly all of this is new code in src/node_recordreplay.cc, so conflicts should only come from the call sites, which are one line each. InitializeRecordReplay() must run early in InitializeOncePerProcess, before V8, OpenSSL and the platform are initialized, and the driver's old space limit is applied after node has processed the command line's V8 options, so that it wins. The --print-build-id early return sits with the other print-and-exit options, and StartExecution creates a checkpoint on the main thread before running the entry script. The process methods are only added to the process_methods binding, so upstream changes to how bindings register methods (for example env->SetMethod(target, ...) becoming SetMethod(context, target, ...) in later v16 releases) must be applied to these registrations too, and the method names must stay in sync with lib/internal/bootstrap/node.js. Includes later changes from #123, #130, #151, #155, #164, #166, #167, Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
added a commit
that referenced
this pull request
Nov 6, 2026
Add build.js script for downloading the Replay driver and compiling Node.js, REPLAY_BACKEND_REV for version tracking, .gitignore updates, and node.gyp change to include node_record_replay_driver.cc. build.js can use a local driver (REPLAY_LOCAL_DRIVER_DIR), builds into out/, strips Nix paths from the build environment, and only rewrites node_record_replay_driver.cc when its contents change, so make does not rebuild the embedded driver needlessly. Includes later changes from #123, #124, #125, #127, #128, #132, #136, #147, #172, #185, #186, #198, #200, #219, #221, #225 and #227. Co-authored-by: Domi <Domiii@users.noreply.github.com> Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
added a commit
that referenced
this pull request
Nov 6, 2026
Add src/node_recordreplay.cc with Replay's node integration: loading the driver (InitializeRecordReplay and OpenDriverHandle, from RECORD_REPLAY_DRIVER or the copy embedded in the binary), the symbol table of driver function pointers, attaching the recorder with the build ID, recording the command line arguments and the argv metadata, and RecordReplayFinishRecording, which appends the recording ID to RECORD_REPLAY_RECORDING_ID_FILE unless the recording is unusable. The node::recordreplay namespace holds the helpers the rest of node uses: callback region scopes, whether the recording has finished, whether a call is inside a callback the driver intercepts, whether events are available (recording or replaying, with events neither disallowed nor passed through and no divergence) or recorded, and ThrowIfEventsUnavailable, which makes an operation that cannot be replayed throw instead of running unrecorded. Expose the recording primitives to JavaScript as process binding methods: RecordReplayLog, the CDP message pair (a callback for responses and events, and sending a message through a process-owned inspector session), the annotation hook, assertions, script ignoring, the recording ID, the current execution point and elapsed time, and the external references for all of them. Replay's own session connects, dispatches and delivers messages to the frontend as replay code with events disallowed, so none of that work can diverge, and the session is reset from AtExit, where node normally waits for external debugger frontends to disconnect: process.exit() skips Environment destruction, so the session would otherwise survive until static destruction, after V8's platform has been disposed. That also disables the debugger, which leaves WebAssembly modules tiered down (see V8Debugger::disable). In node.cc, initialize record/replay and mark the sibling group map ordered before anything else, apply the old space limit the driver asks for (REPLAY_RECORD_MAX_OLD_SPACE_MB / REPLAY_REPLAY_MAX_OLD_SPACE_MB, read through RecordReplayMaxOldSpaceMb) as a V8 flag after the command line's, so that the arguments and process.execArgv stay the same when replaying, print the build ID and exit for --print-build-id, create the first checkpoint on the main thread before the entry script runs, and leave V8's WebAssembly trap handler disabled while recording/replaying, so V8 keeps emitting bounds checks instead of relying on a SIGSEGV the recorder treats as a crash. Rebase note: nearly all of this is new code in src/node_recordreplay.cc, so conflicts should only come from the call sites, which are one line each. InitializeRecordReplay() must run early in InitializeOncePerProcess, before V8, OpenSSL and the platform are initialized, and the driver's old space limit is applied after node has processed the command line's V8 options, so that it wins. The --print-build-id early return sits with the other print-and-exit options, and StartExecution creates a checkpoint on the main thread before running the entry script. The process methods are only added to the process_methods binding, so upstream changes to how bindings register methods (for example env->SetMethod(target, ...) becoming SetMethod(context, target, ...) in later v16 releases) must be applied to these registrations too, and the method names must stay in sync with lib/internal/bootstrap/node.js. Includes later changes from #123, #130, #151, #155, #164, #166, #167, #168, #169, #176, #178, #181 and #215. Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
added a commit
that referenced
this pull request
Nov 6, 2026
Add build.js script for downloading the Replay driver and compiling Node.js, REPLAY_BACKEND_REV for version tracking, .gitignore updates, and node.gyp change to include node_record_replay_driver.cc. build.js can use a local driver (REPLAY_LOCAL_DRIVER_DIR), builds into out/, strips Nix paths from the build environment, and only rewrites node_record_replay_driver.cc when its contents change, so make does not rebuild the embedded driver needlessly. Includes later changes from #123, #124, #125, #127, #128, #132, #136, #147, #172, #185, #186, #198, #200, #219, #221, #225 and #227. Co-authored-by: Domi <Domiii@users.noreply.github.com> Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
added a commit
that referenced
this pull request
Nov 6, 2026
Add src/node_recordreplay.cc with Replay's node integration: loading the driver (InitializeRecordReplay and OpenDriverHandle, from RECORD_REPLAY_DRIVER or the copy embedded in the binary), the symbol table of driver function pointers, attaching the recorder with the build ID, recording the command line arguments and the argv metadata, and RecordReplayFinishRecording, which appends the recording ID to RECORD_REPLAY_RECORDING_ID_FILE unless the recording is unusable. The node::recordreplay namespace holds the helpers the rest of node uses: callback region scopes, whether the recording has finished, whether a call is inside a callback the driver intercepts, whether events are available (recording or replaying, with events neither disallowed nor passed through and no divergence) or recorded, and ThrowIfEventsUnavailable, which makes an operation that cannot be replayed throw instead of running unrecorded. Expose the recording primitives to JavaScript as process binding methods: RecordReplayLog, the CDP message pair (a callback for responses and events, and sending a message through a process-owned inspector session), the annotation hook, assertions, script ignoring, the recording ID, the current execution point and elapsed time, and the external references for all of them. Replay's own session connects, dispatches and delivers messages to the frontend as replay code with events disallowed, so none of that work can diverge, and the session is reset from AtExit, where node normally waits for external debugger frontends to disconnect: process.exit() skips Environment destruction, so the session would otherwise survive until static destruction, after V8's platform has been disposed. That also disables the debugger, which leaves WebAssembly modules tiered down (see V8Debugger::disable). In node.cc, initialize record/replay and mark the sibling group map ordered before anything else, apply the old space limit the driver asks for (REPLAY_RECORD_MAX_OLD_SPACE_MB / REPLAY_REPLAY_MAX_OLD_SPACE_MB, read through RecordReplayMaxOldSpaceMb) as a V8 flag after the command line's, so that the arguments and process.execArgv stay the same when replaying, print the build ID and exit for --print-build-id, create the first checkpoint on the main thread before the entry script runs, and leave V8's WebAssembly trap handler disabled while recording/replaying, so V8 keeps emitting bounds checks instead of relying on a SIGSEGV the recorder treats as a crash. Rebase note: nearly all of this is new code in src/node_recordreplay.cc, so conflicts should only come from the call sites, which are one line each. InitializeRecordReplay() must run early in InitializeOncePerProcess, before V8, OpenSSL and the platform are initialized, and the driver's old space limit is applied after node has processed the command line's V8 options, so that it wins. The --print-build-id early return sits with the other print-and-exit options, and StartExecution creates a checkpoint on the main thread before running the entry script. The process methods are only added to the process_methods binding, so upstream changes to how bindings register methods (for example env->SetMethod(target, ...) becoming SetMethod(context, target, ...) in later v16 releases) must be applied to these registrations too, and the method names must stay in sync with lib/internal/bootstrap/node.js. Includes later changes from #123, #130, #151, #155, #164, #166, #167, Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 6, 2026
Add build.js script for downloading the Replay driver and compiling Node.js, REPLAY_BACKEND_REV for version tracking, .gitignore updates, and node.gyp change to include node_record_replay_driver.cc. build.js can use a local driver (REPLAY_LOCAL_DRIVER_DIR), builds into out/, strips Nix paths from the build environment, and only rewrites node_record_replay_driver.cc when its contents change, so make does not rebuild the embedded driver needlessly. Includes later changes from #123, #124, #125, #127, #128, #132, #136, #147, #172, #185, #186, #198, #200, #219, #221, #225 and #227. Co-authored-by: Domi <Domiii@users.noreply.github.com> Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 6, 2026
Add build.js script for downloading the Replay driver and compiling Node.js, REPLAY_BACKEND_REV for version tracking, .gitignore updates, and node.gyp change to include node_record_replay_driver.cc. build.js can use a local driver (REPLAY_LOCAL_DRIVER_DIR), builds into out/, strips Nix paths from the build environment, and only rewrites node_record_replay_driver.cc when its contents change, so make does not rebuild the embedded driver needlessly. Includes later changes from #123, #124, #125, #127, #128, #132, #136, #147, #172, #185, #186, #198, #200, #219, #221, #225 and #227. Co-authored-by: Domi <Domiii@users.noreply.github.com> Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 6, 2026
Add build.js script for downloading the Replay driver and compiling Node.js, REPLAY_BACKEND_REV for version tracking, .gitignore updates, and node.gyp change to include node_record_replay_driver.cc. build.js can use a local driver (REPLAY_LOCAL_DRIVER_DIR), builds into out/, strips Nix paths from the build environment, and only rewrites node_record_replay_driver.cc when its contents change, so make does not rebuild the embedded driver needlessly. Includes later changes from #123, #124, #125, #127, #128, #132, #136, #147, #172, #185, #186, #198, #200, #219, #221, #225 and #227. Co-authored-by: Domi <Domiii@users.noreply.github.com> Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 6, 2026
Add src/node_recordreplay.cc with Replay's node integration: loading the driver (InitializeRecordReplay and OpenDriverHandle, from RECORD_REPLAY_DRIVER or the copy embedded in the binary), the symbol table of driver function pointers, attaching the recorder with the build ID, recording the command line arguments and the argv metadata, and RecordReplayFinishRecording, which appends the recording ID to RECORD_REPLAY_RECORDING_ID_FILE unless the recording is unusable. The node::recordreplay namespace holds the helpers the rest of node uses: callback region scopes, whether the recording has finished, whether a call is inside a callback the driver intercepts, whether events are available (recording or replaying, with events neither disallowed nor passed through and no divergence) or recorded, and ThrowIfEventsUnavailable, which makes an operation that cannot be replayed throw instead of running unrecorded. Expose the recording primitives to JavaScript as process binding methods: RecordReplayLog, the CDP message pair (a callback for responses and events, and sending a message through a process-owned inspector session), the annotation hook, assertions, script ignoring, the recording ID, the current execution point and elapsed time, and the external references for all of them. Replay's own session connects, dispatches and delivers messages to the frontend as replay code with events disallowed, so none of that work can diverge, and the session is reset from AtExit, where node normally waits for external debugger frontends to disconnect: process.exit() skips Environment destruction, so the session would otherwise survive until static destruction, after V8's platform has been disposed. That also disables the debugger, which leaves WebAssembly modules tiered down (see V8Debugger::disable). In node.cc, initialize record/replay and mark the sibling group map ordered before anything else, apply the old space limit the driver asks for (REPLAY_RECORD_MAX_OLD_SPACE_MB / REPLAY_REPLAY_MAX_OLD_SPACE_MB, read through RecordReplayMaxOldSpaceMb) as a V8 flag after the command line's, so that the arguments and process.execArgv stay the same when replaying, print the build ID and exit for --print-build-id, create the first checkpoint on the main thread before the entry script runs, and leave V8's WebAssembly trap handler disabled while recording/replaying, so V8 keeps emitting bounds checks instead of relying on a SIGSEGV the recorder treats as a crash. libuv keeps a pointer into argv for the process title rather than copying it, so whichever argv uv_setup_args() sees decides the title. Start() calls it before InitializeOncePerProcess(), where the driver replaces the arguments with the recording's, so a replay reported its own argv[0] instead. Node sends that title to a debugger frontend as the execution context's name, where it diverged from the recording's and the write to the frontend's socket was a different length, so the replay sets the arguments up again once the driver has installed them. Rebase note: nearly all of this is new code in src/node_recordreplay.cc, so conflicts should only come from the call sites, which are one line each. InitializeRecordReplay() must run early in InitializeOncePerProcess, before V8, OpenSSL and the platform are initialized, and the driver's old space limit is applied after node has processed the command line's V8 options, so that it wins. The --print-build-id early return sits with the other print-and-exit options, and StartExecution creates a checkpoint on the main thread before running the entry script. The process methods are only added to the process_methods binding, so upstream changes to how bindings register methods (for example env->SetMethod(target, ...) becoming SetMethod(context, target, ...) in later v16 releases) must be applied to these registrations too, and the method names must stay in sync with lib/internal/bootstrap/node.js. Includes later changes from #123, #130, #151, #155, #164, #166, #167, Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 6, 2026
Add src/node_recordreplay.cc with Replay's node integration: loading the driver (InitializeRecordReplay and OpenDriverHandle, from RECORD_REPLAY_DRIVER or the copy embedded in the binary), the symbol table of driver function pointers, attaching the recorder with the build ID, recording the command line arguments and the argv metadata, and RecordReplayFinishRecording, which appends the recording ID to RECORD_REPLAY_RECORDING_ID_FILE unless the recording is unusable. The node::recordreplay namespace holds the helpers the rest of node uses: callback region scopes, whether the recording has finished, whether a call is inside a callback the driver intercepts, whether events are available (recording or replaying, with events neither disallowed nor passed through and no divergence) or recorded, and ThrowIfEventsUnavailable, which makes an operation that cannot be replayed throw instead of running unrecorded. Expose the recording primitives to JavaScript as process binding methods: RecordReplayLog, the CDP message pair (a callback for responses and events, and sending a message through a process-owned inspector session), the annotation hook, assertions, script ignoring, the recording ID, the current execution point and elapsed time, and the external references for all of them. Replay's own session connects, dispatches and delivers messages to the frontend as replay code with events disallowed, so none of that work can diverge, and the session is reset from AtExit, where node normally waits for external debugger frontends to disconnect: process.exit() skips Environment destruction, so the session would otherwise survive until static destruction, after V8's platform has been disposed. That also disables the debugger, which leaves WebAssembly modules tiered down (see V8Debugger::disable). In node.cc, initialize record/replay and mark the sibling group map ordered before anything else, apply the old space limit the driver asks for (REPLAY_RECORD_MAX_OLD_SPACE_MB / REPLAY_REPLAY_MAX_OLD_SPACE_MB, read through RecordReplayMaxOldSpaceMb) as a V8 flag after the command line's, so that the arguments and process.execArgv stay the same when replaying, print the build ID and exit for --print-build-id, create the first checkpoint on the main thread before the entry script runs, and leave V8's WebAssembly trap handler disabled while recording/replaying, so V8 keeps emitting bounds checks instead of relying on a SIGSEGV the recorder treats as a crash. Rebase note: nearly all of this is new code in src/node_recordreplay.cc, so conflicts should only come from the call sites, which are one line each. InitializeRecordReplay() must run early in InitializeOncePerProcess, before V8, OpenSSL and the platform are initialized, and the driver's old space limit is applied after node has processed the command line's V8 options, so that it wins. The --print-build-id early return sits with the other print-and-exit options, and StartExecution creates a checkpoint on the main thread before running the entry script. The process methods are only added to the process_methods binding, so upstream changes to how bindings register methods (for example env->SetMethod(target, ...) becoming SetMethod(context, target, ...) in later v16 releases) must be applied to these registrations too, and the method names must stay in sync with lib/internal/bootstrap/node.js. Includes later changes from #123, #130, #151, #155, #164, #166, #167, Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 6, 2026
Add src/node_recordreplay.cc with Replay's node integration: loading the driver (InitializeRecordReplay and OpenDriverHandle, from RECORD_REPLAY_DRIVER or the copy embedded in the binary), the symbol table of driver function pointers, attaching the recorder with the build ID, recording the command line arguments and the argv metadata, and RecordReplayFinishRecording, which appends the recording ID to RECORD_REPLAY_RECORDING_ID_FILE unless the recording is unusable. The node::recordreplay namespace holds the helpers the rest of node uses: callback region scopes, whether the recording has finished, whether a call is inside a callback the driver intercepts, whether events are available (recording or replaying, with events neither disallowed nor passed through and no divergence) or recorded, and ThrowIfEventsUnavailable, which makes an operation that cannot be replayed throw instead of running unrecorded. Expose the recording primitives to JavaScript as process binding methods: RecordReplayLog, the CDP message pair (a callback for responses and events, and sending a message through a process-owned inspector session), the annotation hook, assertions, script ignoring, the recording ID, the current execution point and elapsed time, and the external references for all of them. Replay's own session connects, dispatches and delivers messages to the frontend as replay code with events disallowed, so none of that work can diverge, and the session is reset from AtExit, where node normally waits for external debugger frontends to disconnect: process.exit() skips Environment destruction, so the session would otherwise survive until static destruction, after V8's platform has been disposed. That also disables the debugger, which leaves WebAssembly modules tiered down (see V8Debugger::disable). In node.cc, initialize record/replay and mark the sibling group map ordered before anything else, apply the old space limit the driver asks for (REPLAY_RECORD_MAX_OLD_SPACE_MB / REPLAY_REPLAY_MAX_OLD_SPACE_MB, read through RecordReplayMaxOldSpaceMb) as a V8 flag after the command line's, so that the arguments and process.execArgv stay the same when replaying, print the build ID and exit for --print-build-id, create the first checkpoint on the main thread before the entry script runs, and leave V8's WebAssembly trap handler disabled while recording/replaying, so V8 keeps emitting bounds checks instead of relying on a SIGSEGV the recorder treats as a crash. Rebase note: nearly all of this is new code in src/node_recordreplay.cc, so conflicts should only come from the call sites, which are one line each. InitializeRecordReplay() must run early in InitializeOncePerProcess, before V8, OpenSSL and the platform are initialized, and the driver's old space limit is applied after node has processed the command line's V8 options, so that it wins. The --print-build-id early return sits with the other print-and-exit options, and StartExecution creates a checkpoint on the main thread before running the entry script. The process methods are only added to the process_methods binding, so upstream changes to how bindings register methods (for example env->SetMethod(target, ...) becoming SetMethod(context, target, ...) in later v16 releases) must be applied to these registrations too, and the method names must stay in sync with lib/internal/bootstrap/node.js. Includes later changes from #123, #130, #151, #155, #164, #166, #167, #168, #169, #176, #178, #181 and #215. Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
added a commit
that referenced
this pull request
Nov 6, 2026
Add build.js script for downloading the Replay driver and compiling Node.js, REPLAY_BACKEND_REV for version tracking, .gitignore updates, and node.gyp change to include node_record_replay_driver.cc. build.js can use a local driver (REPLAY_LOCAL_DRIVER_DIR), builds into out/, strips Nix paths from the build environment, and only rewrites node_record_replay_driver.cc when its contents change, so make does not rebuild the embedded driver needlessly. Includes later changes from #123, #124, #125, #127, #128, #132, #136, #147, #172, #185, #186, #198, #200, #219, #221, #225 and #227. Co-authored-by: Domi <Domiii@users.noreply.github.com> Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
added a commit
that referenced
this pull request
Nov 6, 2026
Add src/node_recordreplay.cc with Replay's node integration: loading the driver (InitializeRecordReplay and OpenDriverHandle, from RECORD_REPLAY_DRIVER or the copy embedded in the binary), the symbol table of driver function pointers, attaching the recorder with the build ID, recording the command line arguments and the argv metadata, and RecordReplayFinishRecording, which appends the recording ID to RECORD_REPLAY_RECORDING_ID_FILE unless the recording is unusable. The node::recordreplay namespace holds the helpers the rest of node uses: callback region scopes, whether the recording has finished, whether a call is inside a callback the driver intercepts, whether events are available (recording or replaying, with events neither disallowed nor passed through and no divergence) or recorded, and ThrowIfEventsUnavailable, which makes an operation that cannot be replayed throw instead of running unrecorded. Expose the recording primitives to JavaScript as process binding methods: RecordReplayLog, the CDP message pair (a callback for responses and events, and sending a message through a process-owned inspector session), the annotation hook, assertions, script ignoring, the recording ID, the current execution point and elapsed time, and the external references for all of them. Replay's own session connects, dispatches and delivers messages to the frontend as replay code with events disallowed, so none of that work can diverge, and the session is reset from AtExit, where node normally waits for external debugger frontends to disconnect: process.exit() skips Environment destruction, so the session would otherwise survive until static destruction, after V8's platform has been disposed. That also disables the debugger, which leaves WebAssembly modules tiered down (see V8Debugger::disable). In node.cc, initialize record/replay and mark the sibling group map ordered before anything else, apply the old space limit the driver asks for (REPLAY_RECORD_MAX_OLD_SPACE_MB / REPLAY_REPLAY_MAX_OLD_SPACE_MB, read through RecordReplayMaxOldSpaceMb) as a V8 flag after the command line's, so that the arguments and process.execArgv stay the same when replaying, print the build ID and exit for --print-build-id, create the first checkpoint on the main thread before the entry script runs, and leave V8's WebAssembly trap handler disabled while recording/replaying, so V8 keeps emitting bounds checks instead of relying on a SIGSEGV the recorder treats as a crash. libuv keeps a pointer into argv for the process title rather than copying it, so whichever argv uv_setup_args() sees decides the title. Start() calls it before InitializeOncePerProcess(), where the driver replaces the arguments with the recording's, so a replay reported its own argv[0] instead. Node sends that title to a debugger frontend as the execution context's name, where it diverged from the recording's and the write to the frontend's socket was a different length, so the replay sets the arguments up again once the driver has installed them. Rebase note: nearly all of this is new code in src/node_recordreplay.cc, so conflicts should only come from the call sites, which are one line each. InitializeRecordReplay() must run early in InitializeOncePerProcess, before V8, OpenSSL and the platform are initialized, and the driver's old space limit is applied after node has processed the command line's V8 options, so that it wins. The --print-build-id early return sits with the other print-and-exit options, and StartExecution creates a checkpoint on the main thread before running the entry script. The process methods are only added to the process_methods binding, so upstream changes to how bindings register methods (for example env->SetMethod(target, ...) becoming SetMethod(context, target, ...) in later v16 releases) must be applied to these registrations too, and the method names must stay in sync with lib/internal/bootstrap/node.js. Includes later changes from #123, #130, #151, #155, #164, #166, #167, Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Add build.js script for downloading the Replay driver and compiling Node.js, REPLAY_BACKEND_REV for version tracking, .gitignore updates, and node.gyp change to include node_record_replay_driver.cc. build.js can use a local driver (REPLAY_LOCAL_DRIVER_DIR), builds into out/, strips Nix paths from the build environment, and only rewrites node_record_replay_driver.cc when its contents change, so make does not rebuild the embedded driver needlessly. Includes later changes from #123, #124, #125, #127, #128, #132, #136, #147, #172, #185, #186, #198, #200, #219, #221, #225 and #227. Co-authored-by: Domi <Domiii@users.noreply.github.com> Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Add build.js script for downloading the Replay driver and compiling Node.js, REPLAY_BACKEND_REV for version tracking, .gitignore updates, and node.gyp change to include node_record_replay_driver.cc. build.js can use a local driver (REPLAY_LOCAL_DRIVER_DIR), builds into out/, strips Nix paths from the build environment, and only rewrites node_record_replay_driver.cc when its contents change, so make does not rebuild the embedded driver needlessly. Includes later changes from #123, #124, #125, #127, #128, #132, #136, Co-authored-by: Domi <Domiii@users.noreply.github.com> Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Add src/node_recordreplay.cc with Replay's node integration: loading the driver (InitializeRecordReplay and OpenDriverHandle, from RECORD_REPLAY_DRIVER or the copy embedded in the binary), the symbol table of driver function pointers, attaching the recorder with the build ID, recording the command line arguments and the argv metadata, and RecordReplayFinishRecording, which appends the recording ID to RECORD_REPLAY_RECORDING_ID_FILE unless the recording is unusable. The node::recordreplay namespace holds the helpers the rest of node uses: callback region scopes, whether the recording has finished, whether a call is inside a callback the driver intercepts, whether events are available (recording or replaying, with events neither disallowed nor passed through and no divergence) or recorded, and ThrowIfEventsUnavailable, which makes an operation that cannot be replayed throw instead of running unrecorded. Expose the recording primitives to JavaScript as process binding methods: RecordReplayLog, the CDP message pair (a callback for responses and events, and sending a message through a process-owned inspector session), the annotation hook, assertions, script ignoring, the recording ID, the current execution point and elapsed time, and the external references for all of them. Replay's own session connects, dispatches and delivers messages to the frontend as replay code with events disallowed, so none of that work can diverge, and the session is reset from AtExit, where node normally waits for external debugger frontends to disconnect: process.exit() skips Environment destruction, so the session would otherwise survive until static destruction, after V8's platform has been disposed. That also disables the debugger, which leaves WebAssembly modules tiered down (see V8Debugger::disable). In node.cc, initialize record/replay and mark the sibling group map ordered before anything else, apply the old space limit the driver asks for (REPLAY_RECORD_MAX_OLD_SPACE_MB / REPLAY_REPLAY_MAX_OLD_SPACE_MB, read through RecordReplayMaxOldSpaceMb) as a V8 flag after the command line's, so that the arguments and process.execArgv stay the same when replaying, print the build ID and exit for --print-build-id, create the first checkpoint on the main thread before the entry script runs, and leave V8's WebAssembly trap handler disabled while recording/replaying, so V8 keeps emitting bounds checks instead of relying on a SIGSEGV the recorder treats as a crash. libuv keeps a pointer into argv for the process title rather than copying it, so whichever argv uv_setup_args() sees decides the title. Start() calls it before InitializeOncePerProcess(), where the driver replaces the arguments with the recording's, so a replay reported its own argv[0] instead. Node sends that title to a debugger frontend as the execution context's name, where it diverged from the recording's and the write to the frontend's socket was a different length, so the replay sets the arguments up again once the driver has installed them. Rebase note: nearly all of this is new code in src/node_recordreplay.cc, so conflicts should only come from the call sites, which are one line each. InitializeRecordReplay() must run early in InitializeOncePerProcess, before V8, OpenSSL and the platform are initialized, and the driver's old space limit is applied after node has processed the command line's V8 options, so that it wins. The --print-build-id early return sits with the other print-and-exit options, and StartExecution creates a checkpoint on the main thread before running the entry script. The process methods are only added to the process_methods binding, so upstream changes to how bindings register methods (for example env->SetMethod(target, ...) becoming SetMethod(context, target, ...) in later v16 releases) must be applied to these registrations too, and the method names must stay in sync with lib/internal/bootstrap/node.js. Includes later changes from #123, #130, #151, #155, #164, #166, #167, Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Add src/node_recordreplay.cc with Replay's node integration: loading the driver (InitializeRecordReplay and OpenDriverHandle, from RECORD_REPLAY_DRIVER or the copy embedded in the binary), the symbol table of driver function pointers, attaching the recorder with the build ID, recording the command line arguments and the argv metadata, and RecordReplayFinishRecording, which appends the recording ID to RECORD_REPLAY_RECORDING_ID_FILE unless the recording is unusable. The node::recordreplay namespace holds the helpers the rest of node uses: callback region scopes, whether the recording has finished, whether a call is inside a callback the driver intercepts, whether events are available (recording or replaying, with events neither disallowed nor passed through and no divergence) or recorded, and ThrowIfEventsUnavailable, which makes an operation that cannot be replayed throw instead of running unrecorded. Expose the recording primitives to JavaScript as process binding methods: RecordReplayLog, the CDP message pair (a callback for responses and events, and sending a message through a process-owned inspector session), the annotation hook, assertions, script ignoring, the recording ID, the current execution point and elapsed time, and the external references for all of them. Replay's own session connects, dispatches and delivers messages to the frontend as replay code with events disallowed, so none of that work can diverge, and the session is reset from AtExit, where node normally waits for external debugger frontends to disconnect: process.exit() skips Environment destruction, so the session would otherwise survive until static destruction, after V8's platform has been disposed. That also disables the debugger, which leaves WebAssembly modules tiered down (see V8Debugger::disable). In node.cc, initialize record/replay and mark the sibling group map ordered before anything else, apply the old space limit the driver asks for (REPLAY_RECORD_MAX_OLD_SPACE_MB / REPLAY_REPLAY_MAX_OLD_SPACE_MB, read through RecordReplayMaxOldSpaceMb) as a V8 flag after the command line's, so that the arguments and process.execArgv stay the same when replaying, print the build ID and exit for --print-build-id, create the first checkpoint on the main thread before the entry script runs, and leave V8's WebAssembly trap handler disabled while recording/replaying, so V8 keeps emitting bounds checks instead of relying on a SIGSEGV the recorder treats as a crash. libuv keeps a pointer into argv for the process title rather than copying it, so whichever argv uv_setup_args() sees decides the title. Start() calls it before InitializeOncePerProcess(), where the driver replaces the arguments with the recording's, so a replay reported its own argv[0] instead. Node sends that title to a debugger frontend as the execution context's name, where it diverged from the recording's and the write to the frontend's socket was a different length, so the replay sets the arguments up again once the driver has installed them. Rebase note: nearly all of this is new code in src/node_recordreplay.cc, so conflicts should only come from the call sites, which are one line each. InitializeRecordReplay() must run early in InitializeOncePerProcess, before V8, OpenSSL and the platform are initialized, and the driver's old space limit is applied after node has processed the command line's V8 options, so that it wins. The --print-build-id early return sits with the other print-and-exit options, and StartExecution creates a checkpoint on the main thread before running the entry script. The process methods are only added to the process_methods binding, so upstream changes to how bindings register methods (for example env->SetMethod(target, ...) becoming SetMethod(context, target, ...) in later v16 releases) must be applied to these registrations too, and the method names must stay in sync with lib/internal/bootstrap/node.js. Includes later changes from #123, #130, #151, #155, #164, #166, #167, Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Add build.js script for downloading the Replay driver and compiling Node.js, REPLAY_BACKEND_REV for version tracking, .gitignore updates, and node.gyp change to include node_record_replay_driver.cc. build.js can use a local driver (REPLAY_LOCAL_DRIVER_DIR), builds into out/, strips Nix paths from the build environment, and only rewrites node_record_replay_driver.cc when its contents change, so make does not rebuild the embedded driver needlessly. Includes later changes from #123, #124, #125, #127, #128, #132, #136, Co-authored-by: Domi <Domiii@users.noreply.github.com> Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Add build.js script for downloading the Replay driver and compiling Node.js, REPLAY_BACKEND_REV for version tracking, .gitignore updates, and node.gyp change to include node_record_replay_driver.cc. build.js can use a local driver (REPLAY_LOCAL_DRIVER_DIR), builds into out/, strips Nix paths from the build environment, and only rewrites node_record_replay_driver.cc when its contents change, so make does not rebuild the embedded driver needlessly. Includes later changes from #123, #124, #125, #127, #128, #132, #136, Co-authored-by: Domi <Domiii@users.noreply.github.com> Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Add src/node_recordreplay.cc with Replay's node integration: loading the driver (InitializeRecordReplay and OpenDriverHandle, from RECORD_REPLAY_DRIVER or the copy embedded in the binary), the symbol table of driver function pointers, attaching the recorder with the build ID, recording the command line arguments and the argv metadata, and RecordReplayFinishRecording, which appends the recording ID to RECORD_REPLAY_RECORDING_ID_FILE unless the recording is unusable. The node::recordreplay namespace holds the helpers the rest of node uses: callback region scopes, whether the recording has finished, whether a call is inside a callback the driver intercepts, whether events are available (recording or replaying, with events neither disallowed nor passed through and no divergence) or recorded, and ThrowIfEventsUnavailable, which makes an operation that cannot be replayed throw instead of running unrecorded. Expose the recording primitives to JavaScript as process binding methods: RecordReplayLog, the CDP message pair (a callback for responses and events, and sending a message through a process-owned inspector session), the annotation hook, assertions, script ignoring, the recording ID, the current execution point and elapsed time, and the external references for all of them. Replay's own session connects, dispatches and delivers messages to the frontend as replay code with events disallowed, so none of that work can diverge, and the session is reset from AtExit, where node normally waits for external debugger frontends to disconnect: process.exit() skips Environment destruction, so the session would otherwise survive until static destruction, after V8's platform has been disposed. That also disables the debugger, which leaves WebAssembly modules tiered down (see V8Debugger::disable). In node.cc, initialize record/replay and mark the sibling group map ordered before anything else, apply the old space limit the driver asks for (REPLAY_RECORD_MAX_OLD_SPACE_MB / REPLAY_REPLAY_MAX_OLD_SPACE_MB, read through RecordReplayMaxOldSpaceMb) as a V8 flag after the command line's, so that the arguments and process.execArgv stay the same when replaying, print the build ID and exit for --print-build-id, create the first checkpoint on the main thread before the entry script runs, and leave V8's WebAssembly trap handler disabled while recording/replaying, so V8 keeps emitting bounds checks instead of relying on a SIGSEGV the recorder treats as a crash. libuv keeps a pointer into argv for the process title rather than copying it, so whichever argv uv_setup_args() sees decides the title. Start() calls it before InitializeOncePerProcess(), where the driver replaces the arguments with the recording's, so a replay reported its own argv[0] instead. Node sends that title to a debugger frontend as the execution context's name, where it diverged from the recording's and the write to the frontend's socket was a different length, so the replay sets the arguments up again once the driver has installed them. Rebase note: nearly all of this is new code in src/node_recordreplay.cc, so conflicts should only come from the call sites, which are one line each. InitializeRecordReplay() must run early in InitializeOncePerProcess, before V8, OpenSSL and the platform are initialized, and the driver's old space limit is applied after node has processed the command line's V8 options, so that it wins. The --print-build-id early return sits with the other print-and-exit options, and StartExecution creates a checkpoint on the main thread before running the entry script. The process methods are only added to the process_methods binding, so upstream changes to how bindings register methods (for example env->SetMethod(target, ...) becoming SetMethod(context, target, ...) in later v16 releases) must be applied to these registrations too, and the method names must stay in sync with lib/internal/bootstrap/node.js. Includes later changes from #123, #130, #151, #155, #164, #166, #167, Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Add src/node_recordreplay.cc with Replay's node integration: loading the driver (InitializeRecordReplay and OpenDriverHandle, from RECORD_REPLAY_DRIVER or the copy embedded in the binary), the symbol table of driver function pointers, attaching the recorder with the build ID, recording the command line arguments and the argv metadata, and RecordReplayFinishRecording, which appends the recording ID to RECORD_REPLAY_RECORDING_ID_FILE unless the recording is unusable. The node::recordreplay namespace holds the helpers the rest of node uses: callback region scopes, whether the recording has finished, whether a call is inside a callback the driver intercepts, whether events are available (recording or replaying, with events neither disallowed nor passed through and no divergence) or recorded, and ThrowIfEventsUnavailable, which makes an operation that cannot be replayed throw instead of running unrecorded. Expose the recording primitives to JavaScript as process binding methods: RecordReplayLog, the CDP message pair (a callback for responses and events, and sending a message through a process-owned inspector session), the annotation hook, assertions, script ignoring, the recording ID, the current execution point and elapsed time, and the external references for all of them. Replay's own session connects, dispatches and delivers messages to the frontend as replay code with events disallowed, so none of that work can diverge, and the session is reset from AtExit, where node normally waits for external debugger frontends to disconnect: process.exit() skips Environment destruction, so the session would otherwise survive until static destruction, after V8's platform has been disposed. That also disables the debugger, which leaves WebAssembly modules tiered down (see V8Debugger::disable). In node.cc, initialize record/replay and mark the sibling group map ordered before anything else, apply the old space limit the driver asks for (REPLAY_RECORD_MAX_OLD_SPACE_MB / REPLAY_REPLAY_MAX_OLD_SPACE_MB, read through RecordReplayMaxOldSpaceMb) as a V8 flag after the command line's, so that the arguments and process.execArgv stay the same when replaying, print the build ID and exit for --print-build-id, create the first checkpoint on the main thread before the entry script runs, and leave V8's WebAssembly trap handler disabled while recording/replaying, so V8 keeps emitting bounds checks instead of relying on a SIGSEGV the recorder treats as a crash. libuv keeps a pointer into argv for the process title rather than copying it, so whichever argv uv_setup_args() sees decides the title. Start() calls it before InitializeOncePerProcess(), where the driver replaces the arguments with the recording's, so a replay reported its own argv[0] instead. Node sends that title to a debugger frontend as the execution context's name, where it diverged from the recording's and the write to the frontend's socket was a different length, so the replay sets the arguments up again once the driver has installed them. Rebase note: nearly all of this is new code in src/node_recordreplay.cc, so conflicts should only come from the call sites, which are one line each. InitializeRecordReplay() must run early in InitializeOncePerProcess, before V8, OpenSSL and the platform are initialized, and the driver's old space limit is applied after node has processed the command line's V8 options, so that it wins. The --print-build-id early return sits with the other print-and-exit options, and StartExecution creates a checkpoint on the main thread before running the entry script. The process methods are only added to the process_methods binding, so upstream changes to how bindings register methods (for example env->SetMethod(target, ...) becoming SetMethod(context, target, ...) in later v16 releases) must be applied to these registrations too, and the method names must stay in sync with lib/internal/bootstrap/node.js. Includes later changes from #123, #130, #151, #155, #164, #166, #167, Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Add build.js script for downloading the Replay driver and compiling Node.js, REPLAY_BACKEND_REV for version tracking, .gitignore updates, and node.gyp change to include node_record_replay_driver.cc. build.js can use a local driver (REPLAY_LOCAL_DRIVER_DIR), builds into out/, strips Nix paths from the build environment, and only rewrites node_record_replay_driver.cc when its contents change, so make does not rebuild the embedded driver needlessly. Includes later changes from #123, #124, #125, #127, #128, #132, #136, Co-authored-by: Domi <Domiii@users.noreply.github.com> Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Add src/node_recordreplay.cc with Replay's node integration: loading the driver (InitializeRecordReplay and OpenDriverHandle, from RECORD_REPLAY_DRIVER or the copy embedded in the binary), the symbol table of driver function pointers, attaching the recorder with the build ID, recording the command line arguments and the argv metadata, and RecordReplayFinishRecording, which appends the recording ID to RECORD_REPLAY_RECORDING_ID_FILE unless the recording is unusable. The node::recordreplay namespace holds the helpers the rest of node uses: callback region scopes, whether the recording has finished, whether a call is inside a callback the driver intercepts, whether events are available (recording or replaying, with events neither disallowed nor passed through and no divergence) or recorded, and ThrowIfEventsUnavailable, which makes an operation that cannot be replayed throw instead of running unrecorded. Expose the recording primitives to JavaScript as process binding methods: RecordReplayLog, the CDP message pair (a callback for responses and events, and sending a message through a process-owned inspector session), the annotation hook, assertions, script ignoring, the recording ID, the current execution point and elapsed time, and the external references for all of them. Replay's own session connects, dispatches and delivers messages to the frontend as replay code with events disallowed, so none of that work can diverge, and the session is reset from AtExit, where node normally waits for external debugger frontends to disconnect: process.exit() skips Environment destruction, so the session would otherwise survive until static destruction, after V8's platform has been disposed. That also disables the debugger, which leaves WebAssembly modules tiered down (see V8Debugger::disable). In node.cc, initialize record/replay and mark the sibling group map ordered before anything else, apply the old space limit the driver asks for (REPLAY_RECORD_MAX_OLD_SPACE_MB / REPLAY_REPLAY_MAX_OLD_SPACE_MB, read through RecordReplayMaxOldSpaceMb) as a V8 flag after the command line's, so that the arguments and process.execArgv stay the same when replaying, print the build ID and exit for --print-build-id, create the first checkpoint on the main thread before the entry script runs, and leave V8's WebAssembly trap handler disabled while recording/replaying, so V8 keeps emitting bounds checks instead of relying on a SIGSEGV the recorder treats as a crash. libuv keeps a pointer into argv for the process title rather than copying it, so whichever argv uv_setup_args() sees decides the title. Start() calls it before InitializeOncePerProcess(), where the driver replaces the arguments with the recording's, so a replay reported its own argv[0] instead. Node sends that title to a debugger frontend as the execution context's name, where it diverged from the recording's and the write to the frontend's socket was a different length, so the replay sets the arguments up again once the driver has installed them. Rebase note: nearly all of this is new code in src/node_recordreplay.cc, so conflicts should only come from the call sites, which are one line each. InitializeRecordReplay() must run early in InitializeOncePerProcess, before V8, OpenSSL and the platform are initialized, and the driver's old space limit is applied after node has processed the command line's V8 options, so that it wins. The --print-build-id early return sits with the other print-and-exit options, and StartExecution creates a checkpoint on the main thread before running the entry script. The process methods are only added to the process_methods binding, so upstream changes to how bindings register methods (for example env->SetMethod(target, ...) becoming SetMethod(context, target, ...) in later v16 releases) must be applied to these registrations too, and the method names must stay in sync with lib/internal/bootstrap/node.js. Includes later changes from #123, #130, #151, #155, #164, #166, #167, Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Add src/node_recordreplay.cc with Replay's node integration: loading the driver (InitializeRecordReplay and OpenDriverHandle, from RECORD_REPLAY_DRIVER or the copy embedded in the binary), the symbol table of driver function pointers, attaching the recorder with the build ID, recording the command line arguments and the argv metadata, and RecordReplayFinishRecording, which appends the recording ID to RECORD_REPLAY_RECORDING_ID_FILE unless the recording is unusable. The node::recordreplay namespace holds the helpers the rest of node uses: callback region scopes, whether the recording has finished, whether a call is inside a callback the driver intercepts, whether events are available (recording or replaying, with events neither disallowed nor passed through and no divergence) or recorded, and ThrowIfEventsUnavailable, which makes an operation that cannot be replayed throw instead of running unrecorded. Expose the recording primitives to JavaScript as process binding methods: RecordReplayLog, the CDP message pair (a callback for responses and events, and sending a message through a process-owned inspector session), the annotation hook, assertions, script ignoring, the recording ID, the current execution point and elapsed time, and the external references for all of them. Replay's own session connects, dispatches and delivers messages to the frontend as replay code with events disallowed, so none of that work can diverge, and the session is reset from AtExit, where node normally waits for external debugger frontends to disconnect: process.exit() skips Environment destruction, so the session would otherwise survive until static destruction, after V8's platform has been disposed. That also disables the debugger, which leaves WebAssembly modules tiered down (see V8Debugger::disable). In node.cc, initialize record/replay and mark the sibling group map ordered before anything else, apply the old space limit the driver asks for (REPLAY_RECORD_MAX_OLD_SPACE_MB / REPLAY_REPLAY_MAX_OLD_SPACE_MB, read through RecordReplayMaxOldSpaceMb) as a V8 flag after the command line's, so that the arguments and process.execArgv stay the same when replaying, print the build ID and exit for --print-build-id, create the first checkpoint on the main thread before the entry script runs, and leave V8's WebAssembly trap handler disabled while recording/replaying, so V8 keeps emitting bounds checks instead of relying on a SIGSEGV the recorder treats as a crash. libuv keeps a pointer into argv for the process title rather than copying it, so whichever argv uv_setup_args() sees decides the title. Start() calls it before InitializeOncePerProcess(), where the driver replaces the arguments with the recording's, so a replay reported its own argv[0] instead. Node sends that title to a debugger frontend as the execution context's name, where it diverged from the recording's and the write to the frontend's socket was a different length, so the replay sets the arguments up again once the driver has installed them. Rebase note: nearly all of this is new code in src/node_recordreplay.cc, so conflicts should only come from the call sites, which are one line each. InitializeRecordReplay() must run early in InitializeOncePerProcess, before V8, OpenSSL and the platform are initialized, and the driver's old space limit is applied after node has processed the command line's V8 options, so that it wins. The --print-build-id early return sits with the other print-and-exit options, and StartExecution creates a checkpoint on the main thread before running the entry script. The process methods are only added to the process_methods binding, so upstream changes to how bindings register methods (for example env->SetMethod(target, ...) becoming SetMethod(context, target, ...) in later v16 releases) must be applied to these registrations too, and the method names must stay in sync with lib/internal/bootstrap/node.js. Includes later changes from #123, #130, #151, #155, #164, #166, #167, Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Add src/node_recordreplay.cc with Replay's node integration: loading the driver (InitializeRecordReplay and OpenDriverHandle, from RECORD_REPLAY_DRIVER or the copy embedded in the binary), the symbol table of driver function pointers, attaching the recorder with the build ID, recording the command line arguments and the argv metadata, and RecordReplayFinishRecording, which appends the recording ID to RECORD_REPLAY_RECORDING_ID_FILE unless the recording is unusable. The node::recordreplay namespace holds the helpers the rest of node uses: callback region scopes, whether the recording has finished, whether a call is inside a callback the driver intercepts, whether events are available (recording or replaying, with events neither disallowed nor passed through and no divergence) or recorded, and ThrowIfEventsUnavailable, which makes an operation that cannot be replayed throw instead of running unrecorded. Expose the recording primitives to JavaScript as process binding methods: RecordReplayLog, the CDP message pair (a callback for responses and events, and sending a message through a process-owned inspector session), the annotation hook, assertions, script ignoring, the recording ID, the current execution point and elapsed time, and the external references for all of them. Replay's own session connects, dispatches and delivers messages to the frontend as replay code with events disallowed, so none of that work can diverge, and the session is reset from AtExit, where node normally waits for external debugger frontends to disconnect: process.exit() skips Environment destruction, so the session would otherwise survive until static destruction, after V8's platform has been disposed. That also disables the debugger, which leaves WebAssembly modules tiered down (see V8Debugger::disable). In node.cc, initialize record/replay and mark the sibling group map ordered before anything else, apply the old space limit the driver asks for (REPLAY_RECORD_MAX_OLD_SPACE_MB / REPLAY_REPLAY_MAX_OLD_SPACE_MB, read through RecordReplayMaxOldSpaceMb) as a V8 flag after the command line's, so that the arguments and process.execArgv stay the same when replaying, print the build ID and exit for --print-build-id, create the first checkpoint on the main thread before the entry script runs, and leave V8's WebAssembly trap handler disabled while recording/replaying, so V8 keeps emitting bounds checks instead of relying on a SIGSEGV the recorder treats as a crash. libuv keeps a pointer into argv for the process title rather than copying it, so whichever argv uv_setup_args() sees decides the title. Start() calls it before InitializeOncePerProcess(), where the driver replaces the arguments with the recording's, so a replay reported its own argv[0] instead. Node sends that title to a debugger frontend as the execution context's name, where it diverged from the recording's and the write to the frontend's socket was a different length, so the replay sets the arguments up again once the driver has installed them. Rebase note: nearly all of this is new code in src/node_recordreplay.cc, so conflicts should only come from the call sites, which are one line each. InitializeRecordReplay() must run early in InitializeOncePerProcess, before V8, OpenSSL and the platform are initialized, and the driver's old space limit is applied after node has processed the command line's V8 options, so that it wins. The --print-build-id early return sits with the other print-and-exit options, and StartExecution creates a checkpoint on the main thread before running the entry script. The process methods are only added to the process_methods binding, so upstream changes to how bindings register methods (for example env->SetMethod(target, ...) becoming SetMethod(context, target, ...) in later v16 releases) must be applied to these registrations too, and the method names must stay in sync with lib/internal/bootstrap/node.js. Includes later changes from #123, #130, #151, #155, #164, #166, #167, Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Add build.js script for downloading the Replay driver and compiling Node.js, REPLAY_BACKEND_REV for version tracking, .gitignore updates, and node.gyp change to include node_record_replay_driver.cc. build.js can use a local driver (REPLAY_LOCAL_DRIVER_DIR), builds into out/, strips Nix paths from the build environment, and only rewrites node_record_replay_driver.cc when its contents change, so make does not rebuild the embedded driver needlessly. Includes later changes from #123, #124, #125, #127, #128, #132, #136, Co-authored-by: Domi <Domiii@users.noreply.github.com> Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Add src/node_recordreplay.cc with Replay's node integration: loading the driver (InitializeRecordReplay and OpenDriverHandle, from RECORD_REPLAY_DRIVER or the copy embedded in the binary), the symbol table of driver function pointers, attaching the recorder with the build ID, recording the command line arguments and the argv metadata, and RecordReplayFinishRecording, which appends the recording ID to RECORD_REPLAY_RECORDING_ID_FILE unless the recording is unusable. The node::recordreplay namespace holds the helpers the rest of node uses: callback region scopes, whether the recording has finished, whether a call is inside a callback the driver intercepts, whether events are available (recording or replaying, with events neither disallowed nor passed through and no divergence) or recorded, and ThrowIfEventsUnavailable, which makes an operation that cannot be replayed throw instead of running unrecorded. Expose the recording primitives to JavaScript as process binding methods: RecordReplayLog, the CDP message pair (a callback for responses and events, and sending a message through a process-owned inspector session), the annotation hook, assertions, script ignoring, the recording ID, the current execution point and elapsed time, and the external references for all of them. Replay's own session connects, dispatches and delivers messages to the frontend as replay code with events disallowed, so none of that work can diverge, and the session is reset from AtExit, where node normally waits for external debugger frontends to disconnect: process.exit() skips Environment destruction, so the session would otherwise survive until static destruction, after V8's platform has been disposed. That also disables the debugger, which leaves WebAssembly modules tiered down (see V8Debugger::disable). In node.cc, initialize record/replay and mark the sibling group map ordered before anything else, apply the old space limit the driver asks for (REPLAY_RECORD_MAX_OLD_SPACE_MB / REPLAY_REPLAY_MAX_OLD_SPACE_MB, read through RecordReplayMaxOldSpaceMb) as a V8 flag after the command line's, so that the arguments and process.execArgv stay the same when replaying, print the build ID and exit for --print-build-id, create the first checkpoint on the main thread before the entry script runs, and leave V8's WebAssembly trap handler disabled while recording/replaying, so V8 keeps emitting bounds checks instead of relying on a SIGSEGV the recorder treats as a crash. libuv keeps a pointer into argv for the process title rather than copying it, so whichever argv uv_setup_args() sees decides the title. Start() calls it before InitializeOncePerProcess(), where the driver replaces the arguments with the recording's, so a replay reported its own argv[0] instead. Node sends that title to a debugger frontend as the execution context's name, where it diverged from the recording's and the write to the frontend's socket was a different length, so the replay sets the arguments up again once the driver has installed them. CDP messages from the inspector are accepted as Latin-1: node 26 hands them over in that encoding, and decoding them as UTF-8 corrupted any message with a byte above 0x7f. Rebase note: nearly all of this is new code in src/node_recordreplay.cc, so conflicts should only come from the call sites, which are one line each. InitializeRecordReplay() must run early in InitializeOncePerProcess, before V8, OpenSSL and the platform are initialized, and the driver's old space limit is applied after node has processed the command line's V8 options, so that it wins. The --print-build-id early return sits with the other print-and-exit options, and StartExecution creates a checkpoint on the main thread before running the entry script. The process methods are only added to the process_methods binding, so upstream changes to how bindings register methods (for example env->SetMethod(target, ...) becoming SetMethod(context, target, ...) in later v16 releases) must be applied to these registrations too, and the method names must stay in sync with lib/internal/bootstrap/node.js. Includes later changes from #123, #130, #151, #155, #164, #166, #167, Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Add build.js script for downloading the Replay driver and compiling Node.js, REPLAY_BACKEND_REV for version tracking, .gitignore updates, and node.gyp change to include node_record_replay_driver.cc. build.js can use a local driver (REPLAY_LOCAL_DRIVER_DIR), builds into out/, strips Nix paths from the build environment, and only rewrites node_record_replay_driver.cc when its contents change, so make does not rebuild the embedded driver needlessly. Includes later changes from #123, #124, #125, #127, #128, #132, #136, Co-authored-by: Domi <Domiii@users.noreply.github.com> Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Add build.js script for downloading the Replay driver and compiling Node.js, REPLAY_BACKEND_REV for version tracking, .gitignore updates, and node.gyp change to include node_record_replay_driver.cc. build.js can use a local driver (REPLAY_LOCAL_DRIVER_DIR), builds into out/, strips Nix paths from the build environment, and only rewrites node_record_replay_driver.cc when its contents change, so make does not rebuild the embedded driver needlessly. Includes later changes from #123, #124, #125, #127, #128, #132, #136, Co-authored-by: Domi <Domiii@users.noreply.github.com> Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Add build.js script for downloading the Replay driver and compiling Node.js, REPLAY_BACKEND_REV for version tracking, .gitignore updates, and node.gyp change to include node_record_replay_driver.cc. build.js can use a local driver (REPLAY_LOCAL_DRIVER_DIR), builds into out/, strips Nix paths from the build environment, and only rewrites node_record_replay_driver.cc when its contents change, so make does not rebuild the embedded driver needlessly. Includes later changes from #123, #124, #125, #127, #128, #132, #136, Co-authored-by: Domi <Domiii@users.noreply.github.com> Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Add build.js script for downloading the Replay driver and compiling Node.js, REPLAY_BACKEND_REV for version tracking, .gitignore updates, and node.gyp change to include node_record_replay_driver.cc. build.js can use a local driver (REPLAY_LOCAL_DRIVER_DIR), builds into out/, strips Nix paths from the build environment, and only rewrites node_record_replay_driver.cc when its contents change, so make does not rebuild the embedded driver needlessly. Includes later changes from #123, #124, #125, #127, #128, #132, #136, Co-authored-by: Domi <Domiii@users.noreply.github.com> Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Add src/node_recordreplay.cc with Replay's node integration: loading the driver (InitializeRecordReplay and OpenDriverHandle, from RECORD_REPLAY_DRIVER or the copy embedded in the binary), the symbol table of driver function pointers, attaching the recorder with the build ID, recording the command line arguments and the argv metadata, and RecordReplayFinishRecording, which appends the recording ID to RECORD_REPLAY_RECORDING_ID_FILE unless the recording is unusable. The node::recordreplay namespace holds the helpers the rest of node uses: callback region scopes, whether the recording has finished, whether a call is inside a callback the driver intercepts, whether events are available (recording or replaying, with events neither disallowed nor passed through and no divergence) or recorded, and ThrowIfEventsUnavailable, which makes an operation that cannot be replayed throw instead of running unrecorded. Expose the recording primitives to JavaScript as process binding methods: RecordReplayLog, the CDP message pair (a callback for responses and events, and sending a message through a process-owned inspector session), the annotation hook, assertions, script ignoring, the recording ID, the current execution point and elapsed time, and the external references for all of them. Replay's own session connects, dispatches and delivers messages to the frontend as replay code with events disallowed, so none of that work can diverge, and the session is reset from AtExit, where node normally waits for external debugger frontends to disconnect: process.exit() skips Environment destruction, so the session would otherwise survive until static destruction, after V8's platform has been disposed. That also disables the debugger, which leaves WebAssembly modules tiered down (see V8Debugger::disable). In node.cc, initialize record/replay and mark the sibling group map ordered before anything else, apply the old space limit the driver asks for (REPLAY_RECORD_MAX_OLD_SPACE_MB / REPLAY_REPLAY_MAX_OLD_SPACE_MB, read through RecordReplayMaxOldSpaceMb) as a V8 flag after the command line's, so that the arguments and process.execArgv stay the same when replaying, print the build ID and exit for --print-build-id, create the first checkpoint on the main thread before the entry script runs, and leave V8's WebAssembly trap handler disabled while recording/replaying, so V8 keeps emitting bounds checks instead of relying on a SIGSEGV the recorder treats as a crash. libuv keeps a pointer into argv for the process title rather than copying it, so whichever argv uv_setup_args() sees decides the title. Start() calls it before InitializeOncePerProcess(), where the driver replaces the arguments with the recording's, so a replay reported its own argv[0] instead. Node sends that title to a debugger frontend as the execution context's name, where it diverged from the recording's and the write to the frontend's socket was a different length, so the replay sets the arguments up again once the driver has installed them. Rebase note: nearly all of this is new code in src/node_recordreplay.cc, so conflicts should only come from the call sites, which are one line each. InitializeRecordReplay() must run early in InitializeOncePerProcess, before V8, OpenSSL and the platform are initialized, and the driver's old space limit is applied after node has processed the command line's V8 options, so that it wins. The --print-build-id early return sits with the other print-and-exit options, and StartExecution creates a checkpoint on the main thread before running the entry script. The process methods are only added to the process_methods binding, so upstream changes to how bindings register methods (for example env->SetMethod(target, ...) becoming SetMethod(context, target, ...) in later v16 releases) must be applied to these registrations too, and the method names must stay in sync with lib/internal/bootstrap/node.js. Includes later changes from #123, #130, #151, #155, #164, #166, #167, Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Add src/node_recordreplay.cc with Replay's node integration: loading the driver (InitializeRecordReplay and OpenDriverHandle, from RECORD_REPLAY_DRIVER or the copy embedded in the binary), the symbol table of driver function pointers, attaching the recorder with the build ID, recording the command line arguments and the argv metadata, and RecordReplayFinishRecording, which appends the recording ID to RECORD_REPLAY_RECORDING_ID_FILE unless the recording is unusable. The node::recordreplay namespace holds the helpers the rest of node uses: callback region scopes, whether the recording has finished, whether a call is inside a callback the driver intercepts, whether events are available (recording or replaying, with events neither disallowed nor passed through and no divergence) or recorded, and ThrowIfEventsUnavailable, which makes an operation that cannot be replayed throw instead of running unrecorded. Expose the recording primitives to JavaScript as process binding methods: RecordReplayLog, the CDP message pair (a callback for responses and events, and sending a message through a process-owned inspector session), the annotation hook, assertions, script ignoring, the recording ID, the current execution point and elapsed time, and the external references for all of them. Replay's own session connects, dispatches and delivers messages to the frontend as replay code with events disallowed, so none of that work can diverge, and the session is reset from AtExit, where node normally waits for external debugger frontends to disconnect: process.exit() skips Environment destruction, so the session would otherwise survive until static destruction, after V8's platform has been disposed. That also disables the debugger, which leaves WebAssembly modules tiered down (see V8Debugger::disable). In node.cc, initialize record/replay and mark the sibling group map ordered before anything else, apply the old space limit the driver asks for (REPLAY_RECORD_MAX_OLD_SPACE_MB / REPLAY_REPLAY_MAX_OLD_SPACE_MB, read through RecordReplayMaxOldSpaceMb) as a V8 flag after the command line's, so that the arguments and process.execArgv stay the same when replaying, print the build ID and exit for --print-build-id, create the first checkpoint on the main thread before the entry script runs, and leave V8's WebAssembly trap handler disabled while recording/replaying, so V8 keeps emitting bounds checks instead of relying on a SIGSEGV the recorder treats as a crash. libuv keeps a pointer into argv for the process title rather than copying it, so whichever argv uv_setup_args() sees decides the title. Start() calls it before InitializeOncePerProcess(), where the driver replaces the arguments with the recording's, so a replay reported its own argv[0] instead. Node sends that title to a debugger frontend as the execution context's name, where it diverged from the recording's and the write to the frontend's socket was a different length, so the replay sets the arguments up again once the driver has installed them. Rebase note: nearly all of this is new code in src/node_recordreplay.cc, so conflicts should only come from the call sites, which are one line each. InitializeRecordReplay() must run early in InitializeOncePerProcess, before V8, OpenSSL and the platform are initialized, and the driver's old space limit is applied after node has processed the command line's V8 options, so that it wins. The --print-build-id early return sits with the other print-and-exit options, and StartExecution creates a checkpoint on the main thread before running the entry script. The process methods are only added to the process_methods binding, so upstream changes to how bindings register methods (for example env->SetMethod(target, ...) becoming SetMethod(context, target, ...) in later v16 releases) must be applied to these registrations too, and the method names must stay in sync with lib/internal/bootstrap/node.js. Includes later changes from #123, #130, #151, #155, #164, #166, #167, Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Add src/node_recordreplay.cc with Replay's node integration: loading the driver (InitializeRecordReplay and OpenDriverHandle, from RECORD_REPLAY_DRIVER or the copy embedded in the binary), the symbol table of driver function pointers, attaching the recorder with the build ID, recording the command line arguments and the argv metadata, and RecordReplayFinishRecording, which appends the recording ID to RECORD_REPLAY_RECORDING_ID_FILE unless the recording is unusable. The node::recordreplay namespace holds the helpers the rest of node uses: callback region scopes, whether the recording has finished, whether a call is inside a callback the driver intercepts, whether events are available (recording or replaying, with events neither disallowed nor passed through and no divergence) or recorded, and ThrowIfEventsUnavailable, which makes an operation that cannot be replayed throw instead of running unrecorded. Expose the recording primitives to JavaScript as process binding methods: RecordReplayLog, the CDP message pair (a callback for responses and events, and sending a message through a process-owned inspector session), the annotation hook, assertions, script ignoring, the recording ID, the current execution point and elapsed time, and the external references for all of them. Replay's own session connects, dispatches and delivers messages to the frontend as replay code with events disallowed, so none of that work can diverge, and the session is reset from AtExit, where node normally waits for external debugger frontends to disconnect: process.exit() skips Environment destruction, so the session would otherwise survive until static destruction, after V8's platform has been disposed. That also disables the debugger, which leaves WebAssembly modules tiered down (see V8Debugger::disable). In node.cc, initialize record/replay and mark the sibling group map ordered before anything else, apply the old space limit the driver asks for (REPLAY_RECORD_MAX_OLD_SPACE_MB / REPLAY_REPLAY_MAX_OLD_SPACE_MB, read through RecordReplayMaxOldSpaceMb) as a V8 flag after the command line's, so that the arguments and process.execArgv stay the same when replaying, print the build ID and exit for --print-build-id, create the first checkpoint on the main thread before the entry script runs, and leave V8's WebAssembly trap handler disabled while recording/replaying, so V8 keeps emitting bounds checks instead of relying on a SIGSEGV the recorder treats as a crash. libuv keeps a pointer into argv for the process title rather than copying it, so whichever argv uv_setup_args() sees decides the title. Start() calls it before InitializeOncePerProcess(), where the driver replaces the arguments with the recording's, so a replay reported its own argv[0] instead. Node sends that title to a debugger frontend as the execution context's name, where it diverged from the recording's and the write to the frontend's socket was a different length, so the replay sets the arguments up again once the driver has installed them. Rebase note: nearly all of this is new code in src/node_recordreplay.cc, so conflicts should only come from the call sites, which are one line each. InitializeRecordReplay() must run early in InitializeOncePerProcess, before V8, OpenSSL and the platform are initialized, and the driver's old space limit is applied after node has processed the command line's V8 options, so that it wins. The --print-build-id early return sits with the other print-and-exit options, and StartExecution creates a checkpoint on the main thread before running the entry script. The process methods are only added to the process_methods binding, so upstream changes to how bindings register methods (for example env->SetMethod(target, ...) becoming SetMethod(context, target, ...) in later v16 releases) must be applied to these registrations too, and the method names must stay in sync with lib/internal/bootstrap/node.js. Includes later changes from #123, #130, #151, #155, #164, #166, #167, Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Add src/node_recordreplay.cc with Replay's node integration: loading the driver (InitializeRecordReplay and OpenDriverHandle, from RECORD_REPLAY_DRIVER or the copy embedded in the binary), the symbol table of driver function pointers, attaching the recorder with the build ID, recording the command line arguments and the argv metadata, and RecordReplayFinishRecording, which appends the recording ID to RECORD_REPLAY_RECORDING_ID_FILE unless the recording is unusable. The node::recordreplay namespace holds the helpers the rest of node uses: callback region scopes, whether the recording has finished, whether a call is inside a callback the driver intercepts, whether events are available (recording or replaying, with events neither disallowed nor passed through and no divergence) or recorded, and ThrowIfEventsUnavailable, which makes an operation that cannot be replayed throw instead of running unrecorded. Expose the recording primitives to JavaScript as process binding methods: RecordReplayLog, the CDP message pair (a callback for responses and events, and sending a message through a process-owned inspector session), the annotation hook, assertions, script ignoring, the recording ID, the current execution point and elapsed time, and the external references for all of them. Replay's own session connects, dispatches and delivers messages to the frontend as replay code with events disallowed, so none of that work can diverge, and the session is reset from AtExit, where node normally waits for external debugger frontends to disconnect: process.exit() skips Environment destruction, so the session would otherwise survive until static destruction, after V8's platform has been disposed. That also disables the debugger, which leaves WebAssembly modules tiered down (see V8Debugger::disable). In node.cc, initialize record/replay and mark the sibling group map ordered before anything else, apply the old space limit the driver asks for (REPLAY_RECORD_MAX_OLD_SPACE_MB / REPLAY_REPLAY_MAX_OLD_SPACE_MB, read through RecordReplayMaxOldSpaceMb) as a V8 flag after the command line's, so that the arguments and process.execArgv stay the same when replaying, print the build ID and exit for --print-build-id, create the first checkpoint on the main thread before the entry script runs, and leave V8's WebAssembly trap handler disabled while recording/replaying, so V8 keeps emitting bounds checks instead of relying on a SIGSEGV the recorder treats as a crash. libuv keeps a pointer into argv for the process title rather than copying it, so whichever argv uv_setup_args() sees decides the title. Start() calls it before InitializeOncePerProcess(), where the driver replaces the arguments with the recording's, so a replay reported its own argv[0] instead. Node sends that title to a debugger frontend as the execution context's name, where it diverged from the recording's and the write to the frontend's socket was a different length, so the replay sets the arguments up again once the driver has installed them. CDP messages from the inspector are accepted as Latin-1: node 26 hands them over in that encoding, and decoding them as UTF-8 corrupted any message with a byte above 0x7f. Rebase note: nearly all of this is new code in src/node_recordreplay.cc, so conflicts should only come from the call sites, which are one line each. InitializeRecordReplay() must run early in InitializeOncePerProcess, before V8, OpenSSL and the platform are initialized, and the driver's old space limit is applied after node has processed the command line's V8 options, so that it wins. The --print-build-id early return sits with the other print-and-exit options, and StartExecution creates a checkpoint on the main thread before running the entry script. The process methods are only added to the process_methods binding, so upstream changes to how bindings register methods (for example env->SetMethod(target, ...) becoming SetMethod(context, target, ...) in later v16 releases) must be applied to these registrations too, and the method names must stay in sync with lib/internal/bootstrap/node.js. Includes later changes from #123, #130, #151, #155, #164, #166, #167, Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Add build.js script for downloading the Replay driver and compiling Node.js, REPLAY_BACKEND_REV for version tracking, .gitignore updates, and node.gyp change to include node_record_replay_driver.cc. build.js can use a local driver (REPLAY_LOCAL_DRIVER_DIR), builds into out/, strips Nix paths from the build environment, and only rewrites node_record_replay_driver.cc when its contents change, so make does not rebuild the embedded driver needlessly. Includes later changes from #123, #124, #125, #127, #128, #132, #136, Co-authored-by: Domi <Domiii@users.noreply.github.com> Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Add src/node_recordreplay.cc with Replay's node integration: loading the driver (InitializeRecordReplay and OpenDriverHandle, from RECORD_REPLAY_DRIVER or the copy embedded in the binary), the symbol table of driver function pointers, attaching the recorder with the build ID, recording the command line arguments and the argv metadata, and RecordReplayFinishRecording, which appends the recording ID to RECORD_REPLAY_RECORDING_ID_FILE unless the recording is unusable. The node::recordreplay namespace holds the helpers the rest of node uses: callback region scopes, whether the recording has finished, whether a call is inside a callback the driver intercepts, whether events are available (recording or replaying, with events neither disallowed nor passed through and no divergence) or recorded, and ThrowIfEventsUnavailable, which makes an operation that cannot be replayed throw instead of running unrecorded. Expose the recording primitives to JavaScript as process binding methods: RecordReplayLog, the CDP message pair (a callback for responses and events, and sending a message through a process-owned inspector session), the annotation hook, assertions, script ignoring, the recording ID, the current execution point and elapsed time, and the external references for all of them. Replay's own session connects, dispatches and delivers messages to the frontend as replay code with events disallowed, so none of that work can diverge, and the session is reset from AtExit, where node normally waits for external debugger frontends to disconnect: process.exit() skips Environment destruction, so the session would otherwise survive until static destruction, after V8's platform has been disposed. That also disables the debugger, which leaves WebAssembly modules tiered down (see V8Debugger::disable). In node.cc, initialize record/replay and mark the sibling group map ordered before anything else, apply the old space limit the driver asks for (REPLAY_RECORD_MAX_OLD_SPACE_MB / REPLAY_REPLAY_MAX_OLD_SPACE_MB, read through RecordReplayMaxOldSpaceMb) as a V8 flag after the command line's, so that the arguments and process.execArgv stay the same when replaying, print the build ID and exit for --print-build-id, create the first checkpoint on the main thread before the entry script runs, and leave V8's WebAssembly trap handler disabled while recording/replaying, so V8 keeps emitting bounds checks instead of relying on a SIGSEGV the recorder treats as a crash. libuv keeps a pointer into argv for the process title rather than copying it, so whichever argv uv_setup_args() sees decides the title. Start() calls it before InitializeOncePerProcess(), where the driver replaces the arguments with the recording's, so a replay reported its own argv[0] instead. Node sends that title to a debugger frontend as the execution context's name, where it diverged from the recording's and the write to the frontend's socket was a different length, so the replay sets the arguments up again once the driver has installed them. CDP messages from the inspector are accepted as Latin-1: node 26 hands them over in that encoding, and decoding them as UTF-8 corrupted any message with a byte above 0x7f. Rebase note: nearly all of this is new code in src/node_recordreplay.cc, so conflicts should only come from the call sites, which are one line each. InitializeRecordReplay() must run early in InitializeOncePerProcess, before V8, OpenSSL and the platform are initialized, and the driver's old space limit is applied after node has processed the command line's V8 options, so that it wins. The --print-build-id early return sits with the other print-and-exit options, and StartExecution creates a checkpoint on the main thread before running the entry script. The process methods are only added to the process_methods binding, so upstream changes to how bindings register methods (for example env->SetMethod(target, ...) becoming SetMethod(context, target, ...) in later v16 releases) must be applied to these registrations too, and the method names must stay in sync with lib/internal/bootstrap/node.js. Includes later changes from #123, #130, #151, #155, #164, #166, #167, Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Add src/node_recordreplay.cc with Replay's node integration: loading the driver (InitializeRecordReplay and OpenDriverHandle, from RECORD_REPLAY_DRIVER or the copy embedded in the binary), the symbol table of driver function pointers, attaching the recorder with the build ID, recording the command line arguments and the argv metadata, and RecordReplayFinishRecording, which appends the recording ID to RECORD_REPLAY_RECORDING_ID_FILE unless the recording is unusable. The node::recordreplay namespace holds the helpers the rest of node uses: callback region scopes, whether the recording has finished, whether a call is inside a callback the driver intercepts, whether events are available (recording or replaying, with events neither disallowed nor passed through and no divergence) or recorded, and ThrowIfEventsUnavailable, which makes an operation that cannot be replayed throw instead of running unrecorded. Expose the recording primitives to JavaScript as process binding methods: RecordReplayLog, the CDP message pair (a callback for responses and events, and sending a message through a process-owned inspector session), the annotation hook, assertions, script ignoring, the recording ID, the current execution point and elapsed time, and the external references for all of them. Replay's own session connects, dispatches and delivers messages to the frontend as replay code with events disallowed, so none of that work can diverge, and the session is reset from AtExit, where node normally waits for external debugger frontends to disconnect: process.exit() skips Environment destruction, so the session would otherwise survive until static destruction, after V8's platform has been disposed. That also disables the debugger, which leaves WebAssembly modules tiered down (see V8Debugger::disable). In node.cc, initialize record/replay and mark the sibling group map ordered before anything else, apply the old space limit the driver asks for (REPLAY_RECORD_MAX_OLD_SPACE_MB / REPLAY_REPLAY_MAX_OLD_SPACE_MB, read through RecordReplayMaxOldSpaceMb) as a V8 flag after the command line's, so that the arguments and process.execArgv stay the same when replaying, print the build ID and exit for --print-build-id, create the first checkpoint on the main thread before the entry script runs, and leave V8's WebAssembly trap handler disabled while recording/replaying, so V8 keeps emitting bounds checks instead of relying on a SIGSEGV the recorder treats as a crash. libuv keeps a pointer into argv for the process title rather than copying it, so whichever argv uv_setup_args() sees decides the title. Start() calls it before InitializeOncePerProcess(), where the driver replaces the arguments with the recording's, so a replay reported its own argv[0] instead. Node sends that title to a debugger frontend as the execution context's name, where it diverged from the recording's and the write to the frontend's socket was a different length, so the replay sets the arguments up again once the driver has installed them. CDP messages from the inspector are accepted as Latin-1: node 26 hands them over in that encoding, and decoding them as UTF-8 corrupted any message with a byte above 0x7f. Rebase note: nearly all of this is new code in src/node_recordreplay.cc, so conflicts should only come from the call sites, which are one line each. InitializeRecordReplay() must run early in InitializeOncePerProcess, before V8, OpenSSL and the platform are initialized, and the driver's old space limit is applied after node has processed the command line's V8 options, so that it wins. The --print-build-id early return sits with the other print-and-exit options, and StartExecution creates a checkpoint on the main thread before running the entry script. The process methods are only added to the process_methods binding, so upstream changes to how bindings register methods (for example env->SetMethod(target, ...) becoming SetMethod(context, target, ...) in later v16 releases) must be applied to these registrations too, and the method names must stay in sync with lib/internal/bootstrap/node.js. Includes later changes from #123, #130, #151, #155, #164, #166, #167, Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Add build.js script for downloading the Replay driver and compiling Node.js, REPLAY_BACKEND_REV for version tracking, .gitignore updates, and node.gyp change to include node_record_replay_driver.cc. build.js can use a local driver (REPLAY_LOCAL_DRIVER_DIR), builds into out/, strips Nix paths from the build environment, and only rewrites node_record_replay_driver.cc when its contents change, so make does not rebuild the embedded driver needlessly. Includes later changes from #123, #124, #125, #127, #128, #132, #136, Co-authored-by: Domi <Domiii@users.noreply.github.com> Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Add src/node_recordreplay.cc with Replay's node integration: loading the driver (InitializeRecordReplay and OpenDriverHandle, from RECORD_REPLAY_DRIVER or the copy embedded in the binary), the symbol table of driver function pointers, attaching the recorder with the build ID, recording the command line arguments and the argv metadata, and RecordReplayFinishRecording, which appends the recording ID to RECORD_REPLAY_RECORDING_ID_FILE unless the recording is unusable. The node::recordreplay namespace holds the helpers the rest of node uses: callback region scopes, whether the recording has finished, whether a call is inside a callback the driver intercepts, whether events are available (recording or replaying, with events neither disallowed nor passed through and no divergence) or recorded, and ThrowIfEventsUnavailable, which makes an operation that cannot be replayed throw instead of running unrecorded. Expose the recording primitives to JavaScript as process binding methods: RecordReplayLog, the CDP message pair (a callback for responses and events, and sending a message through a process-owned inspector session), the annotation hook, assertions, script ignoring, the recording ID, the current execution point and elapsed time, and the external references for all of them. Replay's own session connects, dispatches and delivers messages to the frontend as replay code with events disallowed, so none of that work can diverge, and the session is reset from AtExit, where node normally waits for external debugger frontends to disconnect: process.exit() skips Environment destruction, so the session would otherwise survive until static destruction, after V8's platform has been disposed. That also disables the debugger, which leaves WebAssembly modules tiered down (see V8Debugger::disable). In node.cc, initialize record/replay and mark the sibling group map ordered before anything else, apply the old space limit the driver asks for (REPLAY_RECORD_MAX_OLD_SPACE_MB / REPLAY_REPLAY_MAX_OLD_SPACE_MB, read through RecordReplayMaxOldSpaceMb) as a V8 flag after the command line's, so that the arguments and process.execArgv stay the same when replaying, print the build ID and exit for --print-build-id, create the first checkpoint on the main thread before the entry script runs, and leave V8's WebAssembly trap handler disabled while recording/replaying, so V8 keeps emitting bounds checks instead of relying on a SIGSEGV the recorder treats as a crash. libuv keeps a pointer into argv for the process title rather than copying it, so whichever argv uv_setup_args() sees decides the title. Start() calls it before InitializeOncePerProcess(), where the driver replaces the arguments with the recording's, so a replay reported its own argv[0] instead. Node sends that title to a debugger frontend as the execution context's name, where it diverged from the recording's and the write to the frontend's socket was a different length, so the replay sets the arguments up again once the driver has installed them. Rebase note: nearly all of this is new code in src/node_recordreplay.cc, so conflicts should only come from the call sites, which are one line each. InitializeRecordReplay() must run early in InitializeOncePerProcess, before V8, OpenSSL and the platform are initialized, and the driver's old space limit is applied after node has processed the command line's V8 options, so that it wins. The --print-build-id early return sits with the other print-and-exit options, and StartExecution creates a checkpoint on the main thread before running the entry script. The process methods are only added to the process_methods binding, so upstream changes to how bindings register methods (for example env->SetMethod(target, ...) becoming SetMethod(context, target, ...) in later v16 releases) must be applied to these registrations too, and the method names must stay in sync with lib/internal/bootstrap/node.js. Includes later changes from #123, #130, #151, #155, #164, #166, #167, Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Add build.js script for downloading the Replay driver and compiling Node.js, REPLAY_BACKEND_REV for version tracking, .gitignore updates, and node.gyp change to include node_record_replay_driver.cc. build.js can use a local driver (REPLAY_LOCAL_DRIVER_DIR), builds into out/, strips Nix paths from the build environment, and only rewrites node_record_replay_driver.cc when its contents change, so make does not rebuild the embedded driver needlessly. Includes later changes from #123, #124, #125, #127, #128, #132, #136, Co-authored-by: Domi <Domiii@users.noreply.github.com> Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Add build.js script for downloading the Replay driver and compiling Node.js, REPLAY_BACKEND_REV for version tracking, .gitignore updates, and node.gyp change to include node_record_replay_driver.cc. build.js can use a local driver (REPLAY_LOCAL_DRIVER_DIR), builds into out/, strips Nix paths from the build environment, and only rewrites node_record_replay_driver.cc when its contents change, so make does not rebuild the embedded driver needlessly. Includes later changes from #123, #124, #125, #127, #128, #132, #136, Co-authored-by: Domi <Domiii@users.noreply.github.com> Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Add src/node_recordreplay.cc with Replay's node integration: loading the driver (InitializeRecordReplay and OpenDriverHandle, from RECORD_REPLAY_DRIVER or the copy embedded in the binary), the symbol table of driver function pointers, attaching the recorder with the build ID, recording the command line arguments and the argv metadata, and RecordReplayFinishRecording, which appends the recording ID to RECORD_REPLAY_RECORDING_ID_FILE unless the recording is unusable. The node::recordreplay namespace holds the helpers the rest of node uses: callback region scopes, whether the recording has finished, whether a call is inside a callback the driver intercepts, whether events are available (recording or replaying, with events neither disallowed nor passed through and no divergence) or recorded, and ThrowIfEventsUnavailable, which makes an operation that cannot be replayed throw instead of running unrecorded. Expose the recording primitives to JavaScript as process binding methods: RecordReplayLog, the CDP message pair (a callback for responses and events, and sending a message through a process-owned inspector session), the annotation hook, assertions, script ignoring, the recording ID, the current execution point and elapsed time, and the external references for all of them. Replay's own session connects, dispatches and delivers messages to the frontend as replay code with events disallowed, so none of that work can diverge, and the session is reset from AtExit, where node normally waits for external debugger frontends to disconnect: process.exit() skips Environment destruction, so the session would otherwise survive until static destruction, after V8's platform has been disposed. That also disables the debugger, which leaves WebAssembly modules tiered down (see V8Debugger::disable). In node.cc, initialize record/replay and mark the sibling group map ordered before anything else, apply the old space limit the driver asks for (REPLAY_RECORD_MAX_OLD_SPACE_MB / REPLAY_REPLAY_MAX_OLD_SPACE_MB, read through RecordReplayMaxOldSpaceMb) as a V8 flag after the command line's, so that the arguments and process.execArgv stay the same when replaying, print the build ID and exit for --print-build-id, create the first checkpoint on the main thread before the entry script runs, and leave V8's WebAssembly trap handler disabled while recording/replaying, so V8 keeps emitting bounds checks instead of relying on a SIGSEGV the recorder treats as a crash. libuv keeps a pointer into argv for the process title rather than copying it, so whichever argv uv_setup_args() sees decides the title. Start() calls it before InitializeOncePerProcess(), where the driver replaces the arguments with the recording's, so a replay reported its own argv[0] instead. Node sends that title to a debugger frontend as the execution context's name, where it diverged from the recording's and the write to the frontend's socket was a different length, so the replay sets the arguments up again once the driver has installed them. Rebase note: nearly all of this is new code in src/node_recordreplay.cc, so conflicts should only come from the call sites, which are one line each. InitializeRecordReplay() must run early in InitializeOncePerProcess, before V8, OpenSSL and the platform are initialized, and the driver's old space limit is applied after node has processed the command line's V8 options, so that it wins. The --print-build-id early return sits with the other print-and-exit options, and StartExecution creates a checkpoint on the main thread before running the entry script. The process methods are only added to the process_methods binding, so upstream changes to how bindings register methods (for example env->SetMethod(target, ...) becoming SetMethod(context, target, ...) in later v16 releases) must be applied to these registrations too, and the method names must stay in sync with lib/internal/bootstrap/node.js. Includes later changes from #123, #130, #151, #155, #164, #166, #167, Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Add src/node_recordreplay.cc with Replay's node integration: loading the driver (InitializeRecordReplay and OpenDriverHandle, from RECORD_REPLAY_DRIVER or the copy embedded in the binary), the symbol table of driver function pointers, attaching the recorder with the build ID, recording the command line arguments and the argv metadata, and RecordReplayFinishRecording, which appends the recording ID to RECORD_REPLAY_RECORDING_ID_FILE unless the recording is unusable. The node::recordreplay namespace holds the helpers the rest of node uses: callback region scopes, whether the recording has finished, whether a call is inside a callback the driver intercepts, whether events are available (recording or replaying, with events neither disallowed nor passed through and no divergence) or recorded, and ThrowIfEventsUnavailable, which makes an operation that cannot be replayed throw instead of running unrecorded. Expose the recording primitives to JavaScript as process binding methods: RecordReplayLog, the CDP message pair (a callback for responses and events, and sending a message through a process-owned inspector session), the annotation hook, assertions, script ignoring, the recording ID, the current execution point and elapsed time, and the external references for all of them. Replay's own session connects, dispatches and delivers messages to the frontend as replay code with events disallowed, so none of that work can diverge, and the session is reset from AtExit, where node normally waits for external debugger frontends to disconnect: process.exit() skips Environment destruction, so the session would otherwise survive until static destruction, after V8's platform has been disposed. That also disables the debugger, which leaves WebAssembly modules tiered down (see V8Debugger::disable). In node.cc, initialize record/replay and mark the sibling group map ordered before anything else, apply the old space limit the driver asks for (REPLAY_RECORD_MAX_OLD_SPACE_MB / REPLAY_REPLAY_MAX_OLD_SPACE_MB, read through RecordReplayMaxOldSpaceMb) as a V8 flag after the command line's, so that the arguments and process.execArgv stay the same when replaying, print the build ID and exit for --print-build-id, create the first checkpoint on the main thread before the entry script runs, and leave V8's WebAssembly trap handler disabled while recording/replaying, so V8 keeps emitting bounds checks instead of relying on a SIGSEGV the recorder treats as a crash. libuv keeps a pointer into argv for the process title rather than copying it, so whichever argv uv_setup_args() sees decides the title. Start() calls it before InitializeOncePerProcess(), where the driver replaces the arguments with the recording's, so a replay reported its own argv[0] instead. Node sends that title to a debugger frontend as the execution context's name, where it diverged from the recording's and the write to the frontend's socket was a different length, so the replay sets the arguments up again once the driver has installed them. Rebase note: nearly all of this is new code in src/node_recordreplay.cc, so conflicts should only come from the call sites, which are one line each. InitializeRecordReplay() must run early in InitializeOncePerProcess, before V8, OpenSSL and the platform are initialized, and the driver's old space limit is applied after node has processed the command line's V8 options, so that it wins. The --print-build-id early return sits with the other print-and-exit options, and StartExecution creates a checkpoint on the main thread before running the entry script. The process methods are only added to the process_methods binding, so upstream changes to how bindings register methods (for example env->SetMethod(target, ...) becoming SetMethod(context, target, ...) in later v16 releases) must be applied to these registrations too, and the method names must stay in sync with lib/internal/bootstrap/node.js. Includes later changes from #123, #130, #151, #155, #164, #166, #167, Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 11, 2026
Add build.js script for downloading the Replay driver and compiling Node.js, REPLAY_BACKEND_REV for version tracking, .gitignore updates, and node.gyp change to include node_record_replay_driver.cc. build.js can use a local driver (REPLAY_LOCAL_DRIVER_DIR), builds into out/, strips Nix paths from the build environment, and only rewrites node_record_replay_driver.cc when its contents change, so make does not rebuild the embedded driver needlessly. Includes later changes from #123, #124, #125, #127, #128, #132, #136, Co-authored-by: Domi <Domiii@users.noreply.github.com> Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 11, 2026
Add src/node_recordreplay.cc with Replay's node integration: loading the driver (InitializeRecordReplay and OpenDriverHandle, from RECORD_REPLAY_DRIVER or the copy embedded in the binary), the symbol table of driver function pointers, attaching the recorder with the build ID, recording the command line arguments and the argv metadata, and RecordReplayFinishRecording, which appends the recording ID to RECORD_REPLAY_RECORDING_ID_FILE unless the recording is unusable. The node::recordreplay namespace holds the helpers the rest of node uses: callback region scopes, whether the recording has finished, whether a call is inside a callback the driver intercepts, whether events are available (recording or replaying, with events neither disallowed nor passed through and no divergence) or recorded, and ThrowIfEventsUnavailable, which makes an operation that cannot be replayed throw instead of running unrecorded. Expose the recording primitives to JavaScript as process binding methods: RecordReplayLog, the CDP message pair (a callback for responses and events, and sending a message through a process-owned inspector session), the annotation hook, assertions, script ignoring, the recording ID, the current execution point and elapsed time, and the external references for all of them. Replay's own session connects, dispatches and delivers messages to the frontend as replay code with events disallowed, so none of that work can diverge, and the session is reset from AtExit, where node normally waits for external debugger frontends to disconnect: process.exit() skips Environment destruction, so the session would otherwise survive until static destruction, after V8's platform has been disposed. That also disables the debugger, which leaves WebAssembly modules tiered down (see V8Debugger::disable). In node.cc, initialize record/replay and mark the sibling group map ordered before anything else, apply the old space limit the driver asks for (REPLAY_RECORD_MAX_OLD_SPACE_MB / REPLAY_REPLAY_MAX_OLD_SPACE_MB, read through RecordReplayMaxOldSpaceMb) as a V8 flag after the command line's, so that the arguments and process.execArgv stay the same when replaying, print the build ID and exit for --print-build-id, create the first checkpoint on the main thread before the entry script runs, and leave V8's WebAssembly trap handler disabled while recording/replaying, so V8 keeps emitting bounds checks instead of relying on a SIGSEGV the recorder treats as a crash. libuv keeps a pointer into argv for the process title rather than copying it, so whichever argv uv_setup_args() sees decides the title. Start() calls it before InitializeOncePerProcess(), where the driver replaces the arguments with the recording's, so a replay reported its own argv[0] instead. Node sends that title to a debugger frontend as the execution context's name, where it diverged from the recording's and the write to the frontend's socket was a different length, so the replay sets the arguments up again once the driver has installed them. CDP messages from the inspector are accepted as Latin-1: node 26 hands them over in that encoding, and decoding them as UTF-8 corrupted any message with a byte above 0x7f. Rebase note: nearly all of this is new code in src/node_recordreplay.cc, so conflicts should only come from the call sites, which are one line each. InitializeRecordReplay() must run early in InitializeOncePerProcess, before V8, OpenSSL and the platform are initialized, and the driver's old space limit is applied after node has processed the command line's V8 options, so that it wins. The --print-build-id early return sits with the other print-and-exit options, and StartExecution creates a checkpoint on the main thread before running the entry script. The process methods are only added to the process_methods binding, so upstream changes to how bindings register methods (for example env->SetMethod(target, ...) becoming SetMethod(context, target, ...) in later v16 releases) must be applied to these registrations too, and the method names must stay in sync with lib/internal/bootstrap/node.js. Includes later changes from #123, #130, #151, #155, #164, #166, #167, Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
added a commit
that referenced
this pull request
Nov 11, 2026
Add build.js script for downloading the Replay driver and compiling Node.js, REPLAY_BACKEND_REV for version tracking, .gitignore updates, and node.gyp change to include node_record_replay_driver.cc. build.js can use a local driver (REPLAY_LOCAL_DRIVER_DIR), builds into out/, strips Nix paths from the build environment, and only rewrites node_record_replay_driver.cc when its contents change, so make does not rebuild the embedded driver needlessly. Includes later changes from #123, #124, #125, #127, #128, #132, #136, Co-authored-by: Domi <Domiii@users.noreply.github.com> Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
added a commit
that referenced
this pull request
Nov 11, 2026
Add src/node_recordreplay.cc with Replay's node integration: loading the driver (InitializeRecordReplay and OpenDriverHandle, from RECORD_REPLAY_DRIVER or the copy embedded in the binary), the symbol table of driver function pointers, attaching the recorder with the build ID, recording the command line arguments and the argv metadata, and RecordReplayFinishRecording, which appends the recording ID to RECORD_REPLAY_RECORDING_ID_FILE unless the recording is unusable. The node::recordreplay namespace holds the helpers the rest of node uses: callback region scopes, whether the recording has finished, whether a call is inside a callback the driver intercepts, whether events are available (recording or replaying, with events neither disallowed nor passed through and no divergence) or recorded, and ThrowIfEventsUnavailable, which makes an operation that cannot be replayed throw instead of running unrecorded. Expose the recording primitives to JavaScript as process binding methods: RecordReplayLog, the CDP message pair (a callback for responses and events, and sending a message through a process-owned inspector session), the annotation hook, assertions, script ignoring, the recording ID, the current execution point and elapsed time, and the external references for all of them. Replay's own session connects, dispatches and delivers messages to the frontend as replay code with events disallowed, so none of that work can diverge, and the session is reset from AtExit, where node normally waits for external debugger frontends to disconnect: process.exit() skips Environment destruction, so the session would otherwise survive until static destruction, after V8's platform has been disposed. That also disables the debugger, which leaves WebAssembly modules tiered down (see V8Debugger::disable). In node.cc, initialize record/replay and mark the sibling group map ordered before anything else, apply the old space limit the driver asks for (REPLAY_RECORD_MAX_OLD_SPACE_MB / REPLAY_REPLAY_MAX_OLD_SPACE_MB, read through RecordReplayMaxOldSpaceMb) as a V8 flag after the command line's, so that the arguments and process.execArgv stay the same when replaying, print the build ID and exit for --print-build-id, create the first checkpoint on the main thread before the entry script runs, and leave V8's WebAssembly trap handler disabled while recording/replaying, so V8 keeps emitting bounds checks instead of relying on a SIGSEGV the recorder treats as a crash. libuv keeps a pointer into argv for the process title rather than copying it, so whichever argv uv_setup_args() sees decides the title. Start() calls it before InitializeOncePerProcess(), where the driver replaces the arguments with the recording's, so a replay reported its own argv[0] instead. Node sends that title to a debugger frontend as the execution context's name, where it diverged from the recording's and the write to the frontend's socket was a different length, so the replay sets the arguments up again once the driver has installed them. CDP messages from the inspector are accepted as Latin-1: node 26 hands them over in that encoding, and decoding them as UTF-8 corrupted any message with a byte above 0x7f. Rebase note: nearly all of this is new code in src/node_recordreplay.cc, so conflicts should only come from the call sites, which are one line each. InitializeRecordReplay() must run early in InitializeOncePerProcess, before V8, OpenSSL and the platform are initialized, and the driver's old space limit is applied after node has processed the command line's V8 options, so that it wins. The --print-build-id early return sits with the other print-and-exit options, and StartExecution creates a checkpoint on the main thread before running the entry script. The process methods are only added to the process_methods binding, so upstream changes to how bindings register methods (for example env->SetMethod(target, ...) becoming SetMethod(context, target, ...) in later v16 releases) must be applied to these registrations too, and the method names must stay in sync with lib/internal/bootstrap/node.js. Includes later changes from #123, #130, #151, #155, #164, #166, #167, Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
added a commit
that referenced
this pull request
Nov 11, 2026
Add build.js script for downloading the Replay driver and compiling Node.js, REPLAY_BACKEND_REV for version tracking, .gitignore updates, and node.gyp change to include node_record_replay_driver.cc. build.js can use a local driver (REPLAY_LOCAL_DRIVER_DIR), builds into out/, strips Nix paths from the build environment, and only rewrites node_record_replay_driver.cc when its contents change, so make does not rebuild the embedded driver needlessly. Includes later changes from #123, #124, #125, #127, #128, #132, #136, Co-authored-by: Domi <Domiii@users.noreply.github.com> Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
added a commit
that referenced
this pull request
Nov 11, 2026
Add src/node_recordreplay.cc with Replay's node integration: loading the driver (InitializeRecordReplay and OpenDriverHandle, from RECORD_REPLAY_DRIVER or the copy embedded in the binary), the symbol table of driver function pointers, attaching the recorder with the build ID, recording the command line arguments and the argv metadata, and RecordReplayFinishRecording, which appends the recording ID to RECORD_REPLAY_RECORDING_ID_FILE unless the recording is unusable. The node::recordreplay namespace holds the helpers the rest of node uses: callback region scopes, whether the recording has finished, whether a call is inside a callback the driver intercepts, whether events are available (recording or replaying, with events neither disallowed nor passed through and no divergence) or recorded, and ThrowIfEventsUnavailable, which makes an operation that cannot be replayed throw instead of running unrecorded. Expose the recording primitives to JavaScript as process binding methods: RecordReplayLog, the CDP message pair (a callback for responses and events, and sending a message through a process-owned inspector session), the annotation hook, assertions, script ignoring, the recording ID, the current execution point and elapsed time, and the external references for all of them. Replay's own session connects, dispatches and delivers messages to the frontend as replay code with events disallowed, so none of that work can diverge, and the session is reset from AtExit, where node normally waits for external debugger frontends to disconnect: process.exit() skips Environment destruction, so the session would otherwise survive until static destruction, after V8's platform has been disposed. That also disables the debugger, which leaves WebAssembly modules tiered down (see V8Debugger::disable). In node.cc, initialize record/replay and mark the sibling group map ordered before anything else, apply the old space limit the driver asks for (REPLAY_RECORD_MAX_OLD_SPACE_MB / REPLAY_REPLAY_MAX_OLD_SPACE_MB, read through RecordReplayMaxOldSpaceMb) as a V8 flag after the command line's, so that the arguments and process.execArgv stay the same when replaying, print the build ID and exit for --print-build-id, create the first checkpoint on the main thread before the entry script runs, and leave V8's WebAssembly trap handler disabled while recording/replaying, so V8 keeps emitting bounds checks instead of relying on a SIGSEGV the recorder treats as a crash. libuv keeps a pointer into argv for the process title rather than copying it, so whichever argv uv_setup_args() sees decides the title. Start() calls it before InitializeOncePerProcess(), where the driver replaces the arguments with the recording's, so a replay reported its own argv[0] instead. Node sends that title to a debugger frontend as the execution context's name, where it diverged from the recording's and the write to the frontend's socket was a different length, so the replay sets the arguments up again once the driver has installed them. CDP messages from the inspector are accepted as Latin-1: node 26 hands them over in that encoding, and decoding them as UTF-8 corrupted any message with a byte above 0x7f. Rebase note: nearly all of this is new code in src/node_recordreplay.cc, so conflicts should only come from the call sites, which are one line each. InitializeRecordReplay() must run early in InitializeOncePerProcess, before V8, OpenSSL and the platform are initialized, and the driver's old space limit is applied after node has processed the command line's V8 options, so that it wins. The --print-build-id early return sits with the other print-and-exit options, and StartExecution creates a checkpoint on the main thread before running the entry script. The process methods are only added to the process_methods binding, so upstream changes to how bindings register methods (for example env->SetMethod(target, ...) becoming SetMethod(context, target, ...) in later v16 releases) must be applied to these registrations too, and the method names must stay in sync with lib/internal/bootstrap/node.js. Includes later changes from #123, #130, #151, #155, #164, #166, #167, Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
added a commit
that referenced
this pull request
Nov 12, 2026
Add build.js script for downloading the Replay driver and compiling Node.js, REPLAY_BACKEND_REV for version tracking, .gitignore updates, and node.gyp change to include node_record_replay_driver.cc. build.js can use a local driver (REPLAY_LOCAL_DRIVER_DIR), builds into out/, strips Nix paths from the build environment, and only rewrites node_record_replay_driver.cc when its contents change, so make does not rebuild the embedded driver needlessly. Includes later changes from #123, #124, #125, #127, #128, #132, #136, Co-authored-by: Domi <Domiii@users.noreply.github.com> Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
added a commit
that referenced
this pull request
Nov 12, 2026
Add src/node_recordreplay.cc with Replay's node integration: loading the driver (InitializeRecordReplay and OpenDriverHandle, from RECORD_REPLAY_DRIVER or the copy embedded in the binary), the symbol table of driver function pointers, attaching the recorder with the build ID, recording the command line arguments and the argv metadata, and RecordReplayFinishRecording, which appends the recording ID to RECORD_REPLAY_RECORDING_ID_FILE unless the recording is unusable. The node::recordreplay namespace holds the helpers the rest of node uses: callback region scopes, whether the recording has finished, whether a call is inside a callback the driver intercepts, whether events are available (recording or replaying, with events neither disallowed nor passed through and no divergence) or recorded, and ThrowIfEventsUnavailable, which makes an operation that cannot be replayed throw instead of running unrecorded. Expose the recording primitives to JavaScript as process binding methods: RecordReplayLog, the CDP message pair (a callback for responses and events, and sending a message through a process-owned inspector session), the annotation hook, assertions, script ignoring, the recording ID, the current execution point and elapsed time, and the external references for all of them. Replay's own session connects, dispatches and delivers messages to the frontend as replay code with events disallowed, so none of that work can diverge, and the session is reset from AtExit, where node normally waits for external debugger frontends to disconnect: process.exit() skips Environment destruction, so the session would otherwise survive until static destruction, after V8's platform has been disposed. That also disables the debugger, which leaves WebAssembly modules tiered down (see V8Debugger::disable). In node.cc, initialize record/replay and mark the sibling group map ordered before anything else, apply the old space limit the driver asks for (REPLAY_RECORD_MAX_OLD_SPACE_MB / REPLAY_REPLAY_MAX_OLD_SPACE_MB, read through RecordReplayMaxOldSpaceMb) as a V8 flag after the command line's, so that the arguments and process.execArgv stay the same when replaying, print the build ID and exit for --print-build-id, create the first checkpoint on the main thread before the entry script runs, and leave V8's WebAssembly trap handler disabled while recording/replaying, so V8 keeps emitting bounds checks instead of relying on a SIGSEGV the recorder treats as a crash. libuv keeps a pointer into argv for the process title rather than copying it, so whichever argv uv_setup_args() sees decides the title. Start() calls it before InitializeOncePerProcess(), where the driver replaces the arguments with the recording's, so a replay reported its own argv[0] instead. Node sends that title to a debugger frontend as the execution context's name, where it diverged from the recording's and the write to the frontend's socket was a different length, so the replay sets the arguments up again once the driver has installed them. CDP messages from the inspector are accepted as Latin-1: node 26 hands them over in that encoding, and decoding them as UTF-8 corrupted any message with a byte above 0x7f. Rebase note: nearly all of this is new code in src/node_recordreplay.cc, so conflicts should only come from the call sites, which are one line each. InitializeRecordReplay() must run early in InitializeOncePerProcess, before V8, OpenSSL and the platform are initialized, and the driver's old space limit is applied after node has processed the command line's V8 options, so that it wins. The --print-build-id early return sits with the other print-and-exit options, and StartExecution creates a checkpoint on the main thread before running the entry script. The process methods are only added to the process_methods binding, so upstream changes to how bindings register methods (for example env->SetMethod(target, ...) becoming SetMethod(context, target, ...) in later v16 releases) must be applied to these registrations too, and the method names must stay in sync with lib/internal/bootstrap/node.js. Includes later changes from #123, #130, #151, #155, #164, #166, #167, Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
No description provided.