Skip to content

Declutter formatting changes and more before rebase - #215

Merged
Andarist merged 7 commits into
masterfrom
andarist/node-fork-rebase-declutter
Oct 31, 2026
Merged

Andarist merged 7 commits into
masterfrom
andarist/node-fork-rebase-declutter

Conversation

@Andarist

@Andarist Andarist commented Oct 31, 2026 •

Copy link
Copy Markdown
Member

Three changes that make the fork's diff against upstream v16.14.2 smaller and easier to rebase, without changing behavior:

  • Restore upstream formatting in patched files. Reverts clang-format and rewrapping changes to upstream lines (ast.h was formatted wholesale) and puts new parameters on their own lines. It only changes whitespace: for every touched C/C++ file, the code with comments stripped, the `#` directives and the comment text are unchanged.
  • Move node's record/replay driver and process methods into `src/node_recordreplay.cc`. The code moves unchanged out of node.cc and node_process_methods.cc. Each upstream file keeps a few declarations and one call per hook.
  • Shape the ICU sweep and `~Worker` patches to leave upstream lines alone. `sweepCache()` now returns early instead of having its call site wrapped. `~Worker` declares the watchdog before the upstream lock, so the upstream body no longer moves into a new block. The only reordering is that the `Debug()` log line now prints before the watchdog join.

The deps/v8 code layout is unchanged on purpose: it matches replayio/chromium-v8, which keeps porting between the two easy.

Testing: the build succeeds. The node-recording suite passes 128 of 129. The one failure, long-full-gc-ephemeron-chain, also fails on an unmodified HEAD build.

Andarist and others added 7 commits October 30, 2026 23:47
Reverts whitespace and line-wrapping changes the fork made to upstream
v16.14.2 lines (clang-formatted ast.h, collapsed blank lines, rewrapped
signatures and initializer lists), and puts new parameters on their own
lines so the upstream lines around them stay byte-identical. Whitespace
only: the comment-stripped token streams and preprocessor directives of
every touched file are unchanged.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The driver loading and recordreplay:: helpers in node.cc and the
record/replay process binding methods in node_process_methods.cc move
unchanged into node_recordreplay.cc, leaving declarations and one call
per hook in the upstream files, so rebases only have to carry those.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
sweepCache() has a single caller in each file, so the recording check
becomes an early return there instead of wrapping (and re-indenting) the
upstream call. ~Worker declares the watchdog before the upstream lock,
so it is still joined after the lock is released without moving the
upstream body into a new scope; the only reordering is that the Debug()
line is now logged before the join.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
thread-id.cc's file-local thread_local works when recording/replaying
(the Chromium fork already uses it), so the pthread-key replacement and
its #define go. g_thread_in_wasm_code keeps its replacement: restoring
the extern thread_local makes every replay fail with "Call to unbound
symbol _ZTHN2v88internal12trap_handler21g_thread_in_wasm_codeE", since
other files reach it through its TLS wrapper, so its comments now say so.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The Chromium fork has it back too. DCHECKs aren't compiled into Release
builds.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
It returned early unconditionally, so process.title and --title did
nothing even when node wasn't recording (e.g. RECORD_REPLAY_DONT_RECORD),
failing test-process-title-cli. Recording skips it as well as replaying,
so both report the same title.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The strtod workaround only accepted "0" for a zero result, so "0.0",
"-0" or an underflowing number failed to parse. Check that strtod read
something instead, as the istringstream it replaces did.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
@Andarist
Andarist merged commit c216ed3 into master Oct 31, 2026
2 of 3 checks passed
@Andarist
Andarist deleted the andarist/node-fork-rebase-declutter branch October 31, 2026 17:44
bhackett1024 added a commit that referenced this pull request Nov 5, 2026
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once
in ICU mutex code to ensure deterministic behavior during recording.

Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when
recording or replaying. Both caches are shared by all threads, and
every 100th access sweeps the cache, reading the clock with
uprv_getUTCtime() on whichever thread got there; each isolate's
DateCache loads the time zone names eagerly, so workers starting
together access the cache concurrently and the replay could make that
call on another thread than the recording did. The sweep only frees
entries nobody has used for three minutes, so skipping it is safe.
umtx_isRecordingOrReplaying() asks V8 (see the threading and platform
commit for its weak definitions, which ICU's host tools need), and the
check is an early return in sweepCache(), which has a single caller in
each file, so the upstream call sites stay unchanged.

Rebase note: ICU is vendored, so a new ICU drop has to be re-patched
rather than merged. The invariant is that nothing in ICU reads the
clock, or runs one-time initialization, on whichever thread happens to
get there first, since that thread differs when replaying.

Includes later changes from #176 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
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once
in ICU mutex code to ensure deterministic behavior during recording.

Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when
recording or replaying. Both caches are shared by all threads, and
every 100th access sweeps the cache, reading the clock with
uprv_getUTCtime() on whichever thread got there; each isolate's
DateCache loads the time zone names eagerly, so workers starting
together access the cache concurrently and the replay could make that
call on another thread than the recording did. The sweep only frees
entries nobody has used for three minutes, so skipping it is safe.
umtx_isRecordingOrReplaying() asks V8 (see the threading and platform
commit for its weak definitions, which ICU's host tools need), and the
check is an early return in sweepCache(), which has a single caller in
each file, so the upstream call sites stay unchanged.

Rebase note: ICU is vendored, so a new ICU drop has to be re-patched
rather than merged. The invariant is that nothing in ICU reads the
clock, or runs one-time initialization, on whichever thread happens to
get there first, since that thread differs when replaying.

Includes later changes from #176 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
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once
in ICU mutex code to ensure deterministic behavior during recording.

Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when
recording or replaying. Both caches are shared by all threads, and
every 100th access sweeps the cache, reading the clock with
uprv_getUTCtime() on whichever thread got there; each isolate's
DateCache loads the time zone names eagerly, so workers starting
together access the cache concurrently and the replay could make that
call on another thread than the recording did. The sweep only frees
entries nobody has used for three minutes, so skipping it is safe.
umtx_isRecordingOrReplaying() asks V8 (see the threading and platform
commit for its weak definitions, which ICU's host tools need), and the
check is an early return in sweepCache(), which has a single caller in
each file, so the upstream call sites stay unchanged.

Rebase note: ICU is vendored, so a new ICU drop has to be re-patched
rather than merged. The invariant is that nothing in ICU reads the
clock, or runs one-time initialization, on whichever thread happens to
get there first, since that thread differs when replaying.

Includes later changes from #176 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 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
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once
in ICU mutex code to ensure deterministic behavior during recording.

Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when
recording or replaying. Both caches are shared by all threads, and
every 100th access sweeps the cache, reading the clock with
uprv_getUTCtime() on whichever thread got there; each isolate's
DateCache loads the time zone names eagerly, so workers starting
together access the cache concurrently and the replay could make that
call on another thread than the recording did. The sweep only frees
entries nobody has used for three minutes, so skipping it is safe.
umtx_isRecordingOrReplaying() asks V8 (see the threading and platform
commit for its weak definitions, which ICU's host tools need), and the
check is an early return in sweepCache(), which has a single caller in
each file, so the upstream call sites stay unchanged.

Rebase note: ICU is vendored, so a new ICU drop has to be re-patched
rather than merged. The invariant is that nothing in ICU reads the
clock, or runs one-time initialization, on whichever thread happens to
get there first, since that thread differs when replaying.

Includes later changes from #176 and #215.

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
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once
in ICU mutex code to ensure deterministic behavior during recording.

Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when
recording or replaying. Both caches are shared by all threads, and
every 100th access sweeps the cache, reading the clock with
uprv_getUTCtime() on whichever thread got there; each isolate's
DateCache loads the time zone names eagerly, so workers starting
together access the cache concurrently and the replay could make that
call on another thread than the recording did. The sweep only frees
entries nobody has used for three minutes, so skipping it is safe.
umtx_isRecordingOrReplaying() asks V8 (see the threading and platform
commit for its weak definitions, which ICU's host tools need), and the
check is an early return in sweepCache(), which has a single caller in
each file, so the upstream call sites stay unchanged.

Rebase note: ICU is vendored, so a new ICU drop has to be re-patched
rather than merged. The invariant is that nothing in ICU reads the
clock, or runs one-time initialization, on whichever thread happens to
get there first, since that thread differs when replaying.

Includes later changes from #176 and #215.

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
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once
in ICU mutex code to ensure deterministic behavior during recording.

Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when
recording or replaying. Both caches are shared by all threads, and
every 100th access sweeps the cache, reading the clock with
uprv_getUTCtime() on whichever thread got there; each isolate's
DateCache loads the time zone names eagerly, so workers starting
together access the cache concurrently and the replay could make that
call on another thread than the recording did. The sweep only frees
entries nobody has used for three minutes, so skipping it is safe.
umtx_isRecordingOrReplaying() asks V8 (see the threading and platform
commit for its weak definitions, which ICU's host tools need), and the
check is an early return in sweepCache(), which has a single caller in
each file, so the upstream call sites stay unchanged.

Rebase note: ICU is vendored, so a new ICU drop has to be re-patched
rather than merged. The invariant is that nothing in ICU reads the
clock, or runs one-time initialization, on whichever thread happens to
get there first, since that thread differs when replaying.

Includes later changes from #176 and #215.

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
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once
in ICU mutex code to ensure deterministic behavior during recording.

Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when
recording or replaying. Both caches are shared by all threads, and
every 100th access sweeps the cache, reading the clock with
uprv_getUTCtime() on whichever thread got there; each isolate's
DateCache loads the time zone names eagerly, so workers starting
together access the cache concurrently and the replay could make that
call on another thread than the recording did. The sweep only frees
entries nobody has used for three minutes, so skipping it is safe.
umtx_isRecordingOrReplaying() asks V8 (see the threading and platform
commit for its weak definitions, which ICU's host tools need), and the
check is an early return in sweepCache(), which has a single caller in
each file, so the upstream call sites stay unchanged.

Rebase note: ICU is vendored, so a new ICU drop has to be re-patched
rather than merged. The invariant is that nothing in ICU reads the
clock, or runs one-time initialization, on whichever thread happens to
get there first, since that thread differs when replaying.

Includes later changes from #176 and #215.

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
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once
in ICU mutex code to ensure deterministic behavior during recording.

Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when
recording or replaying. Both caches are shared by all threads, and
every 100th access sweeps the cache, reading the clock with
uprv_getUTCtime() on whichever thread got there; each isolate's
DateCache loads the time zone names eagerly, so workers starting
together access the cache concurrently and the replay could make that
call on another thread than the recording did. The sweep only frees
entries nobody has used for three minutes, so skipping it is safe.
umtx_isRecordingOrReplaying() asks V8 (see the threading and platform
commit for its weak definitions, which ICU's host tools need), and the
check is an early return in sweepCache(), which has a single caller in
each file, so the upstream call sites stay unchanged.

Rebase note: ICU is vendored, so a new ICU drop has to be re-patched
rather than merged. The invariant is that nothing in ICU reads the
clock, or runs one-time initialization, on whichever thread happens to
get there first, since that thread differs when replaying.

Includes later changes from #176 and #215.

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
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once
in ICU mutex code to ensure deterministic behavior during recording.

Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when
recording or replaying. Both caches are shared by all threads, and
every 100th access sweeps the cache, reading the clock with
uprv_getUTCtime() on whichever thread got there; each isolate's
DateCache loads the time zone names eagerly, so workers starting
together access the cache concurrently and the replay could make that
call on another thread than the recording did. The sweep only frees
entries nobody has used for three minutes, so skipping it is safe.
umtx_isRecordingOrReplaying() asks V8 (see the threading and platform
commit for its weak definitions, which ICU's host tools need), and the
check is an early return in sweepCache(), which has a single caller in
each file, so the upstream call sites stay unchanged.

Rebase note: ICU is vendored, so a new ICU drop has to be re-patched
rather than merged. The invariant is that nothing in ICU reads the
clock, or runs one-time initialization, on whichever thread happens to
get there first, since that thread differs when replaying.

Includes later changes from #176 and #215.

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
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once
in ICU mutex code to ensure deterministic behavior during recording.

Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when
recording or replaying. Both caches are shared by all threads, and
every 100th access sweeps the cache, reading the clock with
uprv_getUTCtime() on whichever thread got there; each isolate's
DateCache loads the time zone names eagerly, so workers starting
together access the cache concurrently and the replay could make that
call on another thread than the recording did. The sweep only frees
entries nobody has used for three minutes, so skipping it is safe.
umtx_isRecordingOrReplaying() asks V8 (see the threading and platform
commit for its weak definitions, which ICU's host tools need), and the
check is an early return in sweepCache(), which has a single caller in
each file, so the upstream call sites stay unchanged.

Rebase note: ICU is vendored, so a new ICU drop has to be re-patched
rather than merged. The invariant is that nothing in ICU reads the
clock, or runs one-time initialization, on whichever thread happens to
get there first, since that thread differs when replaying.

Includes later changes from #176 and #215.

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
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once
in ICU mutex code to ensure deterministic behavior during recording.

Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when
recording or replaying. Both caches are shared by all threads, and
every 100th access sweeps the cache, reading the clock with
uprv_getUTCtime() on whichever thread got there; each isolate's
DateCache loads the time zone names eagerly, so workers starting
together access the cache concurrently and the replay could make that
call on another thread than the recording did. The sweep only frees
entries nobody has used for three minutes, so skipping it is safe.
umtx_isRecordingOrReplaying() asks V8 (see the threading and platform
commit for its weak definitions, which ICU's host tools need), and the
check is an early return in sweepCache(), which has a single caller in
each file, so the upstream call sites stay unchanged.

Rebase note: ICU is vendored, so a new ICU drop has to be re-patched
rather than merged. The invariant is that nothing in ICU reads the
clock, or runs one-time initialization, on whichever thread happens to
get there first, since that thread differs when replaying.

Includes later changes from #176 and #215.

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
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once
in ICU mutex code to ensure deterministic behavior during recording.

Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when
recording or replaying. Both caches are shared by all threads, and
every 100th access sweeps the cache, reading the clock with
uprv_getUTCtime() on whichever thread got there; each isolate's
DateCache loads the time zone names eagerly, so workers starting
together access the cache concurrently and the replay could make that
call on another thread than the recording did. The sweep only frees
entries nobody has used for three minutes, so skipping it is safe.
umtx_isRecordingOrReplaying() asks V8 (see the threading and platform
commit for its weak definitions, which ICU's host tools need), and the
check is an early return in sweepCache(), which has a single caller in
each file, so the upstream call sites stay unchanged.

Rebase note: ICU is vendored, so a new ICU drop has to be re-patched
rather than merged. The invariant is that nothing in ICU reads the
clock, or runs one-time initialization, on whichever thread happens to
get there first, since that thread differs when replaying.

Includes later changes from #176 and #215.

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
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once
in ICU mutex code to ensure deterministic behavior during recording.

Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when
recording or replaying. Both caches are shared by all threads, and
every 100th access sweeps the cache, reading the clock with
uprv_getUTCtime() on whichever thread got there; each isolate's
DateCache loads the time zone names eagerly, so workers starting
together access the cache concurrently and the replay could make that
call on another thread than the recording did. The sweep only frees
entries nobody has used for three minutes, so skipping it is safe.
umtx_isRecordingOrReplaying() asks V8 (see the threading and platform
commit for its weak definitions, which ICU's host tools need), and the
check is an early return in sweepCache(), which has a single caller in
each file, so the upstream call sites stay unchanged.

Rebase note: ICU is vendored, so a new ICU drop has to be re-patched
rather than merged. The invariant is that nothing in ICU reads the
clock, or runs one-time initialization, on whichever thread happens to
get there first, since that thread differs when replaying.

Includes later changes from #176 and #215.

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
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once
in ICU mutex code to ensure deterministic behavior during recording.

Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when
recording or replaying. Both caches are shared by all threads, and
every 100th access sweeps the cache, reading the clock with
uprv_getUTCtime() on whichever thread got there; each isolate's
DateCache loads the time zone names eagerly, so workers starting
together access the cache concurrently and the replay could make that
call on another thread than the recording did. The sweep only frees
entries nobody has used for three minutes, so skipping it is safe.
umtx_isRecordingOrReplaying() asks V8 (see the threading and platform
commit for its weak definitions, which ICU's host tools need), and the
check is an early return in sweepCache(), which has a single caller in
each file, so the upstream call sites stay unchanged.

Rebase note: ICU is vendored, so a new ICU drop has to be re-patched
rather than merged. The invariant is that nothing in ICU reads the
clock, or runs one-time initialization, on whichever thread happens to
get there first, since that thread differs when replaying.

Includes later changes from #176 and #215.

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
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once
in ICU mutex code to ensure deterministic behavior during recording.

Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when
recording or replaying. Both caches are shared by all threads, and
every 100th access sweeps the cache, reading the clock with
uprv_getUTCtime() on whichever thread got there; each isolate's
DateCache loads the time zone names eagerly, so workers starting
together access the cache concurrently and the replay could make that
call on another thread than the recording did. The sweep only frees
entries nobody has used for three minutes, so skipping it is safe.
umtx_isRecordingOrReplaying() asks V8 (see the threading and platform
commit for its weak definitions, which ICU's host tools need), and the
check is an early return in sweepCache(), which has a single caller in
each file, so the upstream call sites stay unchanged.

Rebase note: ICU is vendored, so a new ICU drop has to be re-patched
rather than merged. The invariant is that nothing in ICU reads the
clock, or runs one-time initialization, on whichever thread happens to
get there first, since that thread differs when replaying.

Includes later changes from #176 and #215.

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
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once
in ICU mutex code to ensure deterministic behavior during recording.

Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when
recording or replaying. Both caches are shared by all threads, and
every 100th access sweeps the cache, reading the clock with
uprv_getUTCtime() on whichever thread got there; each isolate's
DateCache loads the time zone names eagerly, so workers starting
together access the cache concurrently and the replay could make that
call on another thread than the recording did. The sweep only frees
entries nobody has used for three minutes, so skipping it is safe.
umtx_isRecordingOrReplaying() asks V8 (see the threading and platform
commit for its weak definitions, which ICU's host tools need), and the
check is an early return in sweepCache(), which has a single caller in
each file, so the upstream call sites stay unchanged.

Rebase note: ICU is vendored, so a new ICU drop has to be re-patched
rather than merged. The invariant is that nothing in ICU reads the
clock, or runs one-time initialization, on whichever thread happens to
get there first, since that thread differs when replaying.

Includes later changes from #176 and #215.

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
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once
in ICU mutex code to ensure deterministic behavior during recording.

Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when
recording or replaying. Both caches are shared by all threads, and
every 100th access sweeps the cache, reading the clock with
uprv_getUTCtime() on whichever thread got there; each isolate's
DateCache loads the time zone names eagerly, so workers starting
together access the cache concurrently and the replay could make that
call on another thread than the recording did. The sweep only frees
entries nobody has used for three minutes, so skipping it is safe.
umtx_isRecordingOrReplaying() asks V8 (see the threading and platform
commit for its weak definitions, which ICU's host tools need), and the
check is an early return in sweepCache(), which has a single caller in
each file, so the upstream call sites stay unchanged.

Rebase note: ICU is vendored, so a new ICU drop has to be re-patched
rather than merged. The invariant is that nothing in ICU reads the
clock, or runs one-time initialization, on whichever thread happens to
get there first, since that thread differs when replaying.

Includes later changes from #176 and #215.

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
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once
in ICU mutex code to ensure deterministic behavior during recording.

Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when
recording or replaying. Both caches are shared by all threads, and
every 100th access sweeps the cache, reading the clock with
uprv_getUTCtime() on whichever thread got there; each isolate's
DateCache loads the time zone names eagerly, so workers starting
together access the cache concurrently and the replay could make that
call on another thread than the recording did. The sweep only frees
entries nobody has used for three minutes, so skipping it is safe.
umtx_isRecordingOrReplaying() asks V8 (see the threading and platform
commit for its weak definitions, which ICU's host tools need), and the
check is an early return in sweepCache(), which has a single caller in
each file, so the upstream call sites stay unchanged.

Rebase note: ICU is vendored, so a new ICU drop has to be re-patched
rather than merged. The invariant is that nothing in ICU reads the
clock, or runs one-time initialization, on whichever thread happens to
get there first, since that thread differs when replaying.

Includes later changes from #176 and #215.

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
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once
in ICU mutex code to ensure deterministic behavior during recording.

Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when
recording or replaying. Both caches are shared by all threads, and
every 100th access sweeps the cache, reading the clock with
uprv_getUTCtime() on whichever thread got there; each isolate's
DateCache loads the time zone names eagerly, so workers starting
together access the cache concurrently and the replay could make that
call on another thread than the recording did. The sweep only frees
entries nobody has used for three minutes, so skipping it is safe.
umtx_isRecordingOrReplaying() asks V8 (see the threading and platform
commit for its weak definitions, which ICU's host tools need), and the
check is an early return in sweepCache(), which has a single caller in
each file, so the upstream call sites stay unchanged.

Rebase note: ICU is vendored, so a new ICU drop has to be re-patched
rather than merged. The invariant is that nothing in ICU reads the
clock, or runs one-time initialization, on whichever thread happens to
get there first, since that thread differs when replaying.

Includes later changes from #176 and #215.

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
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once
in ICU mutex code to ensure deterministic behavior during recording.

Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when
recording or replaying. Both caches are shared by all threads, and
every 100th access sweeps the cache, reading the clock with
uprv_getUTCtime() on whichever thread got there; each isolate's
DateCache loads the time zone names eagerly, so workers starting
together access the cache concurrently and the replay could make that
call on another thread than the recording did. The sweep only frees
entries nobody has used for three minutes, so skipping it is safe.
umtx_isRecordingOrReplaying() asks V8 (see the threading and platform
commit for its weak definitions, which ICU's host tools need), and the
check is an early return in sweepCache(), which has a single caller in
each file, so the upstream call sites stay unchanged.

Rebase note: ICU is vendored, so a new ICU drop has to be re-patched
rather than merged. The invariant is that nothing in ICU reads the
clock, or runs one-time initialization, on whichever thread happens to
get there first, since that thread differs when replaying.

Includes later changes from #176 and #215.

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
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once
in ICU mutex code to ensure deterministic behavior during recording.

Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when
recording or replaying. Both caches are shared by all threads, and
every 100th access sweeps the cache, reading the clock with
uprv_getUTCtime() on whichever thread got there; each isolate's
DateCache loads the time zone names eagerly, so workers starting
together access the cache concurrently and the replay could make that
call on another thread than the recording did. The sweep only frees
entries nobody has used for three minutes, so skipping it is safe.
umtx_isRecordingOrReplaying() asks V8 (see the threading and platform
commit for its weak definitions, which ICU's host tools need), and the
check is an early return in sweepCache(), which has a single caller in
each file, so the upstream call sites stay unchanged.

Rebase note: ICU is vendored, so a new ICU drop has to be re-patched
rather than merged. The invariant is that nothing in ICU reads the
clock, or runs one-time initialization, on whichever thread happens to
get there first, since that thread differs when replaying.

Includes later changes from #176 and #215.

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
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once
in ICU mutex code to ensure deterministic behavior during recording.

Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when
recording or replaying. Both caches are shared by all threads, and
every 100th access sweeps the cache, reading the clock with
uprv_getUTCtime() on whichever thread got there; each isolate's
DateCache loads the time zone names eagerly, so workers starting
together access the cache concurrently and the replay could make that
call on another thread than the recording did. The sweep only frees
entries nobody has used for three minutes, so skipping it is safe.
umtx_isRecordingOrReplaying() asks V8 (see the threading and platform
commit for its weak definitions, which ICU's host tools need), and the
check is an early return in sweepCache(), which has a single caller in
each file, so the upstream call sites stay unchanged.

Rebase note: ICU is vendored, so a new ICU drop has to be re-patched
rather than merged. The invariant is that nothing in ICU reads the
clock, or runs one-time initialization, on whichever thread happens to
get there first, since that thread differs when replaying.

Includes later changes from #176 and #215.

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
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once
in ICU mutex code to ensure deterministic behavior during recording.

Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when
recording or replaying. Both caches are shared by all threads, and
every 100th access sweeps the cache, reading the clock with
uprv_getUTCtime() on whichever thread got there; each isolate's
DateCache loads the time zone names eagerly, so workers starting
together access the cache concurrently and the replay could make that
call on another thread than the recording did. The sweep only frees
entries nobody has used for three minutes, so skipping it is safe.
umtx_isRecordingOrReplaying() asks V8 (see the threading and platform
commit for its weak definitions, which ICU's host tools need), and the
check is an early return in sweepCache(), which has a single caller in
each file, so the upstream call sites stay unchanged.

Rebase note: ICU is vendored, so a new ICU drop has to be re-patched
rather than merged. The invariant is that nothing in ICU reads the
clock, or runs one-time initialization, on whichever thread happens to
get there first, since that thread differs when replaying.

Includes later changes from #176 and #215.

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
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once
in ICU mutex code to ensure deterministic behavior during recording.

Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when
recording or replaying. Both caches are shared by all threads, and
every 100th access sweeps the cache, reading the clock with
uprv_getUTCtime() on whichever thread got there; each isolate's
DateCache loads the time zone names eagerly, so workers starting
together access the cache concurrently and the replay could make that
call on another thread than the recording did. The sweep only frees
entries nobody has used for three minutes, so skipping it is safe.
umtx_isRecordingOrReplaying() asks V8 (see the threading and platform
commit for its weak definitions, which ICU's host tools need), and the
check is an early return in sweepCache(), which has a single caller in
each file, so the upstream call sites stay unchanged.

Rebase note: ICU is vendored, so a new ICU drop has to be re-patched
rather than merged. The invariant is that nothing in ICU reads the
clock, or runs one-time initialization, on whichever thread happens to
get there first, since that thread differs when replaying.

Includes later changes from #176 and #215.

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
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once
in ICU mutex code to ensure deterministic behavior during recording.

Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when
recording or replaying. Both caches are shared by all threads, and
every 100th access sweeps the cache, reading the clock with
uprv_getUTCtime() on whichever thread got there; each isolate's
DateCache loads the time zone names eagerly, so workers starting
together access the cache concurrently and the replay could make that
call on another thread than the recording did. The sweep only frees
entries nobody has used for three minutes, so skipping it is safe.
umtx_isRecordingOrReplaying() asks V8 (see the threading and platform
commit for its weak definitions, which ICU's host tools need), and the
check is an early return in sweepCache(), which has a single caller in
each file, so the upstream call sites stay unchanged.

Rebase note: ICU is vendored, so a new ICU drop has to be re-patched
rather than merged. The invariant is that nothing in ICU reads the
clock, or runs one-time initialization, on whichever thread happens to
get there first, since that thread differs when replaying.

Includes later changes from #176 and #215.

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
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once
in ICU mutex code to ensure deterministic behavior during recording.

Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when
recording or replaying. Both caches are shared by all threads, and
every 100th access sweeps the cache, reading the clock with
uprv_getUTCtime() on whichever thread got there; each isolate's
DateCache loads the time zone names eagerly, so workers starting
together access the cache concurrently and the replay could make that
call on another thread than the recording did. The sweep only frees
entries nobody has used for three minutes, so skipping it is safe.
umtx_isRecordingOrReplaying() asks V8 (see the threading and platform
commit for its weak definitions, which ICU's host tools need), and the
check is an early return in sweepCache(), which has a single caller in
each file, so the upstream call sites stay unchanged.

Rebase note: ICU is vendored, so a new ICU drop has to be re-patched
rather than merged. The invariant is that nothing in ICU reads the
clock, or runs one-time initialization, on whichever thread happens to
get there first, since that thread differs when replaying.

Includes later changes from #176 and #215.

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
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once
in ICU mutex code to ensure deterministic behavior during recording.

Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when
recording or replaying. Both caches are shared by all threads, and
every 100th access sweeps the cache, reading the clock with
uprv_getUTCtime() on whichever thread got there; each isolate's
DateCache loads the time zone names eagerly, so workers starting
together access the cache concurrently and the replay could make that
call on another thread than the recording did. The sweep only frees
entries nobody has used for three minutes, so skipping it is safe.
umtx_isRecordingOrReplaying() asks V8 (see the threading and platform
commit for its weak definitions, which ICU's host tools need), and the
check is an early return in sweepCache(), which has a single caller in
each file, so the upstream call sites stay unchanged.

Rebase note: ICU is vendored, so a new ICU drop has to be re-patched
rather than merged. The invariant is that nothing in ICU reads the
clock, or runs one-time initialization, on whichever thread happens to
get there first, since that thread differs when replaying.

Includes later changes from #176 and #215.

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
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once
in ICU mutex code to ensure deterministic behavior during recording.

Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when
recording or replaying. Both caches are shared by all threads, and
every 100th access sweeps the cache, reading the clock with
uprv_getUTCtime() on whichever thread got there; each isolate's
DateCache loads the time zone names eagerly, so workers starting
together access the cache concurrently and the replay could make that
call on another thread than the recording did. The sweep only frees
entries nobody has used for three minutes, so skipping it is safe.
umtx_isRecordingOrReplaying() asks V8 (see the threading and platform
commit for its weak definitions, which ICU's host tools need), and the
check is an early return in sweepCache(), which has a single caller in
each file, so the upstream call sites stay unchanged.

Rebase note: ICU is vendored, so a new ICU drop has to be re-patched
rather than merged. The invariant is that nothing in ICU reads the
clock, or runs one-time initialization, on whichever thread happens to
get there first, since that thread differs when replaying.

Includes later changes from #176 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 11, 2026
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once
in ICU mutex code to ensure deterministic behavior during recording.

Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when
recording or replaying. Both caches are shared by all threads, and
every 100th access sweeps the cache, reading the clock with
uprv_getUTCtime() on whichever thread got there; each isolate's
DateCache loads the time zone names eagerly, so workers starting
together access the cache concurrently and the replay could make that
call on another thread than the recording did. The sweep only frees
entries nobody has used for three minutes, so skipping it is safe.
umtx_isRecordingOrReplaying() asks V8 (see the threading and platform
commit for its weak definitions, which ICU's host tools need), and the
check is an early return in sweepCache(), which has a single caller in
each file, so the upstream call sites stay unchanged.

Rebase note: ICU is vendored, so a new ICU drop has to be re-patched
rather than merged. The invariant is that nothing in ICU reads the
clock, or runs one-time initialization, on whichever thread happens to
get there first, since that thread differs when replaying.

Includes later changes from #176 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 11, 2026
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once
in ICU mutex code to ensure deterministic behavior during recording.

Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when
recording or replaying. Both caches are shared by all threads, and
every 100th access sweeps the cache, reading the clock with
uprv_getUTCtime() on whichever thread got there; each isolate's
DateCache loads the time zone names eagerly, so workers starting
together access the cache concurrently and the replay could make that
call on another thread than the recording did. The sweep only frees
entries nobody has used for three minutes, so skipping it is safe.
umtx_isRecordingOrReplaying() asks V8 (see the threading and platform
commit for its weak definitions, which ICU's host tools need), and the
check is an early return in sweepCache(), which has a single caller in
each file, so the upstream call sites stay unchanged.

Rebase note: ICU is vendored, so a new ICU drop has to be re-patched
rather than merged. The invariant is that nothing in ICU reads the
clock, or runs one-time initialization, on whichever thread happens to
get there first, since that thread differs when replaying.

Includes later changes from #176 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 12, 2026
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once
in ICU mutex code to ensure deterministic behavior during recording.

Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when
recording or replaying. Both caches are shared by all threads, and
every 100th access sweeps the cache, reading the clock with
uprv_getUTCtime() on whichever thread got there; each isolate's
DateCache loads the time zone names eagerly, so workers starting
together access the cache concurrently and the replay could make that
call on another thread than the recording did. The sweep only frees
entries nobody has used for three minutes, so skipping it is safe.
umtx_isRecordingOrReplaying() asks V8 (see the threading and platform
commit for its weak definitions, which ICU's host tools need), and the
check is an early return in sweepCache(), which has a single caller in
each file, so the upstream call sites stay unchanged.

Rebase note: ICU is vendored, so a new ICU drop has to be re-patched
rather than merged. The invariant is that nothing in ICU reads the
clock, or runs one-time initialization, on whichever thread happens to
get there first, since that thread differs when replaying.

Includes later changes from #176 and #215.

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.

1 participant