Skip to content

Update recorder to the version free of OpenSSL dependency - #123

Merged
Andarist merged 3 commits into
masterfrom
update-recorder
Apr 16, 2026
Merged

Andarist merged 3 commits into
masterfrom
update-recorder

Conversation

@Andarist

Copy link
Copy Markdown
Member

No description provided.

@Andarist
Andarist requested a review from bhackett1024 April 16, 2026 15:56
@Andarist
Andarist merged commit c9366b6 into master Apr 16, 2026
2 of 3 checks passed
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>
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants