diff --git a/DEPS b/DEPS
index cc10c05..797f60b 100644
--- a/DEPS
+++ b/DEPS
@@ -120,7 +120,7 @@
   "icu_rev": "81d656878ec611cb0b42d52c82e9dae93920d9ba",
   "intl_rev": "9145f308f1458f37630a1ffce3b7d3b471ebbc56",
   "jinja2_rev": "2222b31554f03e62600cd7e383376a7c187967a1",
-  "json_rpc_2_rev": "7e00f893440a72de0637970325e4ea44bd1e8c8e",
+  "json_rpc_2_rev": "2de9a1f9821807fa2c85fd48e2f70b9cbcddcb67",
   "linter_rev": "a8529c6692922b45bc287543b355c90d7b1286d3", # 1.24.0
   "lints_rev": "8294e5648ab49474541527e2911e72e4c5aefe55",
   "logging_rev": "f6979e3bc3b6e1847a08335b7eb6304e18986195",
@@ -155,7 +155,7 @@
   "test_rev": "d54846bc2b5cfa4e1445fda85c5e48a00940aa68",
   "typed_data_rev": "8b19e29bcf4077147de4d67adeabeb48270c65eb",
   "usage_rev": "e85d575d6decb921c57a43b9844bba3607479f56",
-  "vector_math_rev": "0cbed0914d49a6a44555e6d5444c438a4a4c3fc1",
+  "vector_math_rev": "1c72944e8c2f02340a1d90b32aab2e3836cef8cc",
   "watcher_rev": "f76997ab0c857dc5537ac0975a9ada92b54ef949",
   "web_components_rev": "8f57dac273412a7172c8ade6f361b407e2e4ed02",
   "web_socket_channel_rev": "99dbdc5769e19b9eeaf69449a59079153c6a8b1f",
diff --git a/benchmarks/IsolateSendExit/dart/IsolateSendExitLatency.dart b/benchmarks/IsolateSendExit/dart/IsolateSendExitLatency.dart
new file mode 100644
index 0000000..8d00b01
--- /dev/null
+++ b/benchmarks/IsolateSendExit/dart/IsolateSendExitLatency.dart
@@ -0,0 +1,45 @@
+// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+//
+// This test ensures that there are no long pauses when sending large objects
+// via exit/send.
+
+import 'dart:async';
+import 'dart:typed_data';
+import 'dart:math' as math;
+import 'dart:isolate';
+
+import 'latency.dart';
+
+main() async {
+  final statsFuture =
+      measureEventLoopLatency(const Duration(milliseconds: 1), 4000, work: () {
+    // Every 1 ms we allocate some objects which may trigger GC some time.
+    for (int i = 0; i < 32; i++) {
+      List.filled(32 * 1024 ~/ 8, null);
+    }
+  });
+
+  final result = await compute(() {
+    final l = <dynamic>[];
+    for (int i = 0; i < 10 * 1000 * 1000; ++i) {
+      l.add(Object());
+    }
+    return l;
+  });
+  if (result.length != 10 * 1000 * 1000) throw 'failed';
+
+  final stats = await statsFuture;
+  stats.report('IsolateSendExitLatency');
+}
+
+Future<T> compute<T>(T Function() fun) {
+  final rp = ReceivePort();
+  final sp = rp.sendPort;
+  Isolate.spawn((_) {
+    final value = fun();
+    Isolate.exit(sp, value);
+  }, null);
+  return rp.first.then((t) => t as T);
+}
diff --git a/benchmarks/IsolateSendExit/dart/latency.dart b/benchmarks/IsolateSendExit/dart/latency.dart
new file mode 100644
index 0000000..0a5054f
--- /dev/null
+++ b/benchmarks/IsolateSendExit/dart/latency.dart
@@ -0,0 +1,134 @@
+// Copyright (c) 2020, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:async';
+import 'dart:io';
+import 'dart:math' as math;
+import 'dart:typed_data';
+
+/// Measures event loop responsiveness.
+///
+/// Schedules new timer events, [tickDuration] in the future, and measures how
+/// long it takes for these events to actually arrive.
+///
+/// Runs [numberOfTicks] times before completing with [EventLoopLatencyStats].
+Future<EventLoopLatencyStats> measureEventLoopLatency(
+    Duration tickDuration, int numberOfTicks,
+    {void Function()? work}) {
+  final completer = Completer<EventLoopLatencyStats>();
+
+  final tickDurationInUs = tickDuration.inMicroseconds;
+  final buffer = _TickLatencies(numberOfTicks);
+  final sw = Stopwatch()..start();
+  int lastTimestamp = 0;
+
+  void trigger() {
+    final int currentTimestamp = sw.elapsedMicroseconds;
+
+    // Every tick we missed to schedule we'll add with difference to when we
+    // would've scheduled it and when we became responsive again.
+    bool done = false;
+    while (!done && lastTimestamp < (currentTimestamp - tickDurationInUs)) {
+      done = !buffer.add(currentTimestamp - lastTimestamp - tickDurationInUs);
+      lastTimestamp += tickDurationInUs;
+    }
+
+    if (work != null) {
+      work();
+    }
+
+    if (!done) {
+      lastTimestamp = currentTimestamp;
+      Timer(tickDuration, trigger);
+    } else {
+      completer.complete(buffer.makeStats());
+    }
+  }
+
+  Timer(tickDuration, trigger);
+
+  return completer.future;
+}
+
+/// Result of the event loop latency measurement.
+class EventLoopLatencyStats {
+  /// Minimum latency between scheduling a tick and it's arrival (in ms).
+  final double minLatency;
+
+  /// Average latency between scheduling a tick and it's arrival (in ms).
+  final double avgLatency;
+
+  /// Maximum latency between scheduling a tick and it's arrival (in ms).
+  final double maxLatency;
+
+  /// The 50th percentile (median) (in ms).
+  final double percentile50th;
+
+  /// The 90th percentile (in ms).
+  final double percentile90th;
+
+  /// The 95th percentile (in ms).
+  final double percentile95th;
+
+  /// The 99th percentile (in ms).
+  final double percentile99th;
+
+  EventLoopLatencyStats(
+      this.minLatency,
+      this.avgLatency,
+      this.maxLatency,
+      this.percentile50th,
+      this.percentile90th,
+      this.percentile95th,
+      this.percentile99th);
+
+  void report(String name) {
+    print('$name.Min(RunTimeRaw): $minLatency ms.');
+    print('$name.Avg(RunTimeRaw): $avgLatency ms.');
+    print('$name.Percentile50(RunTimeRaw): $percentile50th ms.');
+    print('$name.Percentile90(RunTimeRaw): $percentile90th ms.');
+    print('$name.Percentile95(RunTimeRaw): $percentile95th ms.');
+    print('$name.Percentile99(RunTimeRaw): $percentile99th ms.');
+    print('$name.Max(RunTimeRaw): $maxLatency ms.');
+  }
+}
+
+/// Accumulates tick latencies and makes statistics for it.
+class _TickLatencies {
+  final Uint64List _timestamps;
+  int _index = 0;
+
+  _TickLatencies(int numberOfTicks) : _timestamps = Uint64List(numberOfTicks);
+
+  /// Returns `true` while the buffer has not been filled yet.
+  bool add(int latencyInUs) {
+    _timestamps[_index++] = latencyInUs;
+    return _index < _timestamps.length;
+  }
+
+  EventLoopLatencyStats makeStats() {
+    if (_index != _timestamps.length) {
+      throw 'Buffer has not been fully filled yet.';
+    }
+
+    _timestamps.sort();
+    final length = _timestamps.length;
+    final double avg = _timestamps.fold(0, (int a, int b) => a + b) / length;
+    final int min = _timestamps.fold(0x7fffffffffffffff, math.min);
+    final int max = _timestamps.fold(0, math.max);
+    final percentile50th = _timestamps[50 * length ~/ 100];
+    final percentile90th = _timestamps[90 * length ~/ 100];
+    final percentile95th = _timestamps[95 * length ~/ 100];
+    final percentile99th = _timestamps[99 * length ~/ 100];
+
+    return EventLoopLatencyStats(
+        min / 1000,
+        avg / 1000,
+        max / 1000,
+        percentile50th / 1000,
+        percentile90th / 1000,
+        percentile95th / 1000,
+        percentile99th / 1000);
+  }
+}
diff --git a/benchmarks/IsolateSendExit/dart2/IsolateSendExitLatency.dart b/benchmarks/IsolateSendExit/dart2/IsolateSendExitLatency.dart
new file mode 100644
index 0000000..c165c73
--- /dev/null
+++ b/benchmarks/IsolateSendExit/dart2/IsolateSendExitLatency.dart
@@ -0,0 +1,47 @@
+// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+//
+// This test ensures that there are no long pauses when sending large objects
+// via exit/send.
+
+// @dart=2.9
+
+import 'dart:async';
+import 'dart:typed_data';
+import 'dart:math' as math;
+import 'dart:isolate';
+
+import 'latency.dart';
+
+main() async {
+  final statsFuture =
+      measureEventLoopLatency(const Duration(milliseconds: 1), 4000, work: () {
+    // Every 1 ms we allocate some objects which may trigger GC some time.
+    for (int i = 0; i < 32; i++) {
+      List.filled(32 * 1024 ~/ 8, null);
+    }
+  });
+
+  final result = await compute(() {
+    final l = <dynamic>[];
+    for (int i = 0; i < 10 * 1000 * 1000; ++i) {
+      l.add(Object());
+    }
+    return l;
+  });
+  if (result.length != 10 * 1000 * 1000) throw 'failed';
+
+  final stats = await statsFuture;
+  stats.report('IsolateSendExitLatency');
+}
+
+Future<T> compute<T>(T Function() fun) {
+  final rp = ReceivePort();
+  final sp = rp.sendPort;
+  Isolate.spawn((_) {
+    final value = fun();
+    Isolate.exit(sp, value);
+  }, null);
+  return rp.first.then((t) => t as T);
+}
diff --git a/benchmarks/IsolateSendExit/dart2/latency.dart b/benchmarks/IsolateSendExit/dart2/latency.dart
new file mode 100644
index 0000000..8b3352c
--- /dev/null
+++ b/benchmarks/IsolateSendExit/dart2/latency.dart
@@ -0,0 +1,136 @@
+// Copyright (c) 2020, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// @dart=2.9
+
+import 'dart:async';
+import 'dart:io';
+import 'dart:math' as math;
+import 'dart:typed_data';
+
+/// Measures event loop responsiveness.
+///
+/// Schedules new timer events, [tickDuration] in the future, and measures how
+/// long it takes for these events to actually arrive.
+///
+/// Runs [numberOfTicks] times before completing with [EventLoopLatencyStats].
+Future<EventLoopLatencyStats> measureEventLoopLatency(
+    Duration tickDuration, int numberOfTicks,
+    {void Function() work}) {
+  final completer = Completer<EventLoopLatencyStats>();
+
+  final tickDurationInUs = tickDuration.inMicroseconds;
+  final buffer = _TickLatencies(numberOfTicks);
+  final sw = Stopwatch()..start();
+  int lastTimestamp = 0;
+
+  void trigger() {
+    final int currentTimestamp = sw.elapsedMicroseconds;
+
+    // Every tick we missed to schedule we'll add with difference to when we
+    // would've scheduled it and when we became responsive again.
+    bool done = false;
+    while (!done && lastTimestamp < (currentTimestamp - tickDurationInUs)) {
+      done = !buffer.add(currentTimestamp - lastTimestamp - tickDurationInUs);
+      lastTimestamp += tickDurationInUs;
+    }
+
+    if (work != null) {
+      work();
+    }
+
+    if (!done) {
+      lastTimestamp = currentTimestamp;
+      Timer(tickDuration, trigger);
+    } else {
+      completer.complete(buffer.makeStats());
+    }
+  }
+
+  Timer(tickDuration, trigger);
+
+  return completer.future;
+}
+
+/// Result of the event loop latency measurement.
+class EventLoopLatencyStats {
+  /// Minimum latency between scheduling a tick and it's arrival (in ms).
+  final double minLatency;
+
+  /// Average latency between scheduling a tick and it's arrival (in ms).
+  final double avgLatency;
+
+  /// Maximum latency between scheduling a tick and it's arrival (in ms).
+  final double maxLatency;
+
+  /// The 50th percentile (median) (in ms).
+  final double percentile50th;
+
+  /// The 90th percentile (in ms).
+  final double percentile90th;
+
+  /// The 95th percentile (in ms).
+  final double percentile95th;
+
+  /// The 99th percentile (in ms).
+  final double percentile99th;
+
+  EventLoopLatencyStats(
+      this.minLatency,
+      this.avgLatency,
+      this.maxLatency,
+      this.percentile50th,
+      this.percentile90th,
+      this.percentile95th,
+      this.percentile99th);
+
+  void report(String name) {
+    print('$name.Min(RunTimeRaw): $minLatency ms.');
+    print('$name.Avg(RunTimeRaw): $avgLatency ms.');
+    print('$name.Percentile50(RunTimeRaw): $percentile50th ms.');
+    print('$name.Percentile90(RunTimeRaw): $percentile90th ms.');
+    print('$name.Percentile95(RunTimeRaw): $percentile95th ms.');
+    print('$name.Percentile99(RunTimeRaw): $percentile99th ms.');
+    print('$name.Max(RunTimeRaw): $maxLatency ms.');
+  }
+}
+
+/// Accumulates tick latencies and makes statistics for it.
+class _TickLatencies {
+  final Uint64List _timestamps;
+  int _index = 0;
+
+  _TickLatencies(int numberOfTicks) : _timestamps = Uint64List(numberOfTicks);
+
+  /// Returns `true` while the buffer has not been filled yet.
+  bool add(int latencyInUs) {
+    _timestamps[_index++] = latencyInUs;
+    return _index < _timestamps.length;
+  }
+
+  EventLoopLatencyStats makeStats() {
+    if (_index != _timestamps.length) {
+      throw 'Buffer has not been fully filled yet.';
+    }
+
+    _timestamps.sort();
+    final length = _timestamps.length;
+    final double avg = _timestamps.fold(0, (int a, int b) => a + b) / length;
+    final int min = _timestamps.fold(0x7fffffffffffffff, math.min);
+    final int max = _timestamps.fold(0, math.max);
+    final percentile50th = _timestamps[50 * length ~/ 100];
+    final percentile90th = _timestamps[90 * length ~/ 100];
+    final percentile95th = _timestamps[95 * length ~/ 100];
+    final percentile99th = _timestamps[99 * length ~/ 100];
+
+    return EventLoopLatencyStats(
+        min / 1000,
+        avg / 1000,
+        max / 1000,
+        percentile50th / 1000,
+        percentile90th / 1000,
+        percentile95th / 1000,
+        percentile99th / 1000);
+  }
+}
diff --git a/pkg/analysis_server/lib/src/lsp/json_parsing.dart b/pkg/analysis_server/lib/src/lsp/json_parsing.dart
index f396dde..5b33fea 100644
--- a/pkg/analysis_server/lib/src/lsp/json_parsing.dart
+++ b/pkg/analysis_server/lib/src/lsp/json_parsing.dart
@@ -5,6 +5,7 @@
 import 'dart:collection';
 
 final nullLspJsonReporter = _NullLspJsonReporter();
+final throwingLspJsonReporter = _ThrowingLspJsonReporter();
 
 /// Tracks a path through a JSON object during validation to allow reporting
 /// validation errors with user-friendly paths to the invalid fields.
@@ -51,3 +52,11 @@
   @override
   void reportError(String message) {}
 }
+
+class _ThrowingLspJsonReporter extends LspJsonReporter {
+  @override
+  void reportError(String message) {
+    super.reportError(message);
+    throw errors.join('\n');
+  }
+}
diff --git a/pkg/analysis_server/test/src/cider/cider_service.dart b/pkg/analysis_server/test/src/cider/cider_service.dart
index fbc50e9..35e01af 100644
--- a/pkg/analysis_server/test/src/cider/cider_service.dart
+++ b/pkg/analysis_server/test/src/cider/cider_service.dart
@@ -5,6 +5,7 @@
 import 'dart:convert';
 
 import 'package:analyzer/src/dart/analysis/performance_logger.dart';
+import 'package:analyzer/src/dart/micro/cider_byte_store.dart';
 import 'package:analyzer/src/dart/micro/resolve_file.dart';
 import 'package:analyzer/src/dart/sdk/sdk.dart';
 import 'package:analyzer/src/test_utilities/mock_sdk.dart';
@@ -36,12 +37,13 @@
     )!;
 
     fileResolver = FileResolver(
-      logger,
-      resourceProvider,
-      workspace.createSourceFactory(sdk, null),
-      (String path) => _getDigest(path),
-      null,
+      logger: logger,
+      resourceProvider: resourceProvider,
+      sourceFactory: workspace.createSourceFactory(sdk, null),
+      getFileDigest: (String path) => _getDigest(path),
+      prefetchFiles: null,
       workspace: workspace,
+      byteStore: CiderCachedByteStore(20 * 1024 * 1024 /* 20 MB */),
     );
     fileResolver.testView = FileResolverTestView();
   }
diff --git a/pkg/analysis_server/test/tool/lsp_spec/json_test.dart b/pkg/analysis_server/test/tool/lsp_spec/json_test.dart
index b411ff6..9275e6d 100644
--- a/pkg/analysis_server/test/tool/lsp_spec/json_test.dart
+++ b/pkg/analysis_server/test/tool/lsp_spec/json_test.dart
@@ -130,7 +130,7 @@
 
     test('canParse returns true for in-spec (restricted) enum values', () {
       expect(
-        MarkupKind.canParse('plaintext', nullLspJsonReporter),
+        MarkupKind.canParse('plaintext', throwingLspJsonReporter),
         isTrue,
       );
     });
@@ -138,7 +138,7 @@
     test('canParse returns true for out-of-spec (unrestricted) enum values',
         () {
       expect(
-        SymbolKind.canParse(-1, nullLspJsonReporter),
+        SymbolKind.canParse(-1, throwingLspJsonReporter),
         isTrue,
       );
     });
@@ -150,7 +150,7 @@
         'processId': null,
         'rootUri': null,
         'capabilities': <String, Object>{}
-      }, nullLspJsonReporter);
+      }, throwingLspJsonReporter);
       expect(canParse, isTrue);
     });
 
@@ -160,7 +160,7 @@
       final canParse = CreateFile.canParse({
         'kind': 'create',
         'uri': 'file:///temp/foo',
-      }, nullLspJsonReporter);
+      }, throwingLspJsonReporter);
       expect(canParse, isTrue);
     });
 
@@ -185,14 +185,17 @@
         null: true,
         'invalid': false,
       };
-      for (final testValue in testTraceValues.keys) {
-        final expected = testTraceValues[testValue];
+      for (final entry in testTraceValues.entries) {
+        final testValue = entry.key;
+        final expected = entry.value;
+        final reporter =
+            expected ? throwingLspJsonReporter : nullLspJsonReporter;
         final canParse = InitializeParams.canParse({
           'processId': null,
           'rootUri': null,
           'capabilities': <String, Object>{},
           'trace': testValue,
-        }, nullLspJsonReporter);
+        }, reporter);
         expect(canParse, expected,
             reason: 'InitializeParams.canParse returned $canParse with a '
                 '"trace" value of "$testValue" but expected $expected');
@@ -201,11 +204,12 @@
 
     test('canParse validates optional fields', () {
       expect(
-        RenameFileOptions.canParse(<String, Object>{}, nullLspJsonReporter),
+        RenameFileOptions.canParse(<String, Object>{}, throwingLspJsonReporter),
         isTrue,
       );
       expect(
-        RenameFileOptions.canParse({'overwrite': true}, nullLspJsonReporter),
+        RenameFileOptions.canParse(
+            {'overwrite': true}, throwingLspJsonReporter),
         isTrue,
       );
       expect(
@@ -217,7 +221,7 @@
     test('canParse ignores fields not in the spec', () {
       expect(
         RenameFileOptions.canParse(
-            {'overwrite': true, 'invalidField': true}, nullLspJsonReporter),
+            {'overwrite': true, 'invalidField': true}, throwingLspJsonReporter),
         isTrue,
       );
       expect(
@@ -398,6 +402,15 @@
       expect(message.params, isNull);
       expect(message.jsonrpc, equals('test'));
     });
+
+    test('parses JSON with integers in double fields', () {
+      final input = '{"alpha":1.0,"blue":0,"green":1,"red":1.5}';
+      final message = Color.fromJson(jsonDecode(input) as Map<String, Object?>);
+      expect(message.alpha, 1.0);
+      expect(message.blue, 0.0);
+      expect(message.green, 1.0);
+      expect(message.red, 1.5);
+    });
   });
 
   test('objects with lists can round-trip through to json and back', () {
diff --git a/pkg/analyzer/lib/dart/analysis/results.dart b/pkg/analyzer/lib/dart/analysis/results.dart
index 97198d9..604cf8f 100644
--- a/pkg/analyzer/lib/dart/analysis/results.dart
+++ b/pkg/analyzer/lib/dart/analysis/results.dart
@@ -120,6 +120,17 @@
         SomeResolvedLibraryResult {}
 
 /// The type of [InvalidResult] returned when the given file is not a library,
+/// but an augmentation of a library.
+///
+/// Clients may not extend, implement or mix-in this class.
+class NotLibraryButAugmentationResult
+    implements
+        InvalidResult,
+        SomeLibraryElementResult,
+        SomeParsedLibraryResult,
+        SomeResolvedLibraryResult {}
+
+/// The type of [InvalidResult] returned when the given file is not a library,
 /// but a part of a library.
 ///
 /// Clients may not extend, implement or mix-in this class.
@@ -311,6 +322,8 @@
 /// The result of building the element model for a single file.
 ///
 /// Clients may not extend, implement or mix-in this class.
+///
+/// TODO(scheglov) Stop implementing [FileResult].
 abstract class UnitElementResult implements SomeUnitElementResult, FileResult {
   /// The element of the file.
   CompilationUnitElement get element;
diff --git a/pkg/analyzer/lib/src/dart/analysis/driver.dart b/pkg/analyzer/lib/src/dart/analysis/driver.dart
index 3aa510f..8b58a3c 100644
--- a/pkg/analyzer/lib/src/dart/analysis/driver.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/driver.dart
@@ -741,8 +741,14 @@
           return CannotResolveUriResult();
         }
 
-        if (file.isPart) {
+        final kind = file.kind;
+        if (kind is LibraryFileStateKind) {
+        } else if (kind is AugmentationFileStateKind) {
+          return NotLibraryButAugmentationResult();
+        } else if (kind is PartFileStateKind) {
           return NotLibraryButPartResult();
+        } else {
+          throw UnimplementedError('(${kind.runtimeType}) $kind');
         }
 
         var unitResult = await getUnitElement(file.path);
@@ -789,10 +795,15 @@
       return NotPathOfUriResult();
     }
 
-    FileState file = _fsState.getFileForPath(path);
-
-    if (file.isPart) {
+    final file = _fsState.getFileForPath(path);
+    final kind = file.kind;
+    if (kind is LibraryFileStateKind) {
+    } else if (kind is AugmentationFileStateKind) {
+      return NotLibraryButAugmentationResult();
+    } else if (kind is PartFileStateKind) {
       return NotLibraryButPartResult();
+    } else {
+      throw UnimplementedError('(${kind.runtimeType}) $kind');
     }
 
     var units = <ParsedUnitResult>[];
@@ -816,9 +827,6 @@
         if (file == null) {
           return CannotResolveUriResult();
         }
-        if (file.isPart) {
-          return NotLibraryButPartResult();
-        }
         return getParsedLibrary(file.path);
       },
       (externalLibrary) {
@@ -841,25 +849,24 @@
   /// state (including new states of the files previously reported using
   /// [changeFile]), prior to the next time the analysis state transitions
   /// to "idle".
-  Future<SomeResolvedLibraryResult> getResolvedLibrary(String path) {
+  Future<SomeResolvedLibraryResult> getResolvedLibrary(String path) async {
     if (!_isAbsolutePath(path)) {
-      return Future.value(
-        InvalidPathResult(),
-      );
+      return InvalidPathResult();
     }
 
     if (!_fsState.hasUri(path)) {
-      return Future.value(
-        NotPathOfUriResult(),
-      );
+      return NotPathOfUriResult();
     }
 
-    FileState file = _fsState.getFileForPath(path);
-
-    if (file.isPart) {
-      return Future.value(
-        NotLibraryButPartResult(),
-      );
+    final file = _fsState.getFileForPath(path);
+    final kind = file.kind;
+    if (kind is LibraryFileStateKind) {
+    } else if (kind is AugmentationFileStateKind) {
+      return NotLibraryButAugmentationResult();
+    } else if (kind is PartFileStateKind) {
+      return NotLibraryButPartResult();
+    } else {
+      throw UnimplementedError('(${kind.runtimeType}) $kind');
     }
 
     // Schedule analysis.
@@ -888,9 +895,6 @@
         if (file == null) {
           return CannotResolveUriResult();
         }
-        if (file.isPart) {
-          return NotLibraryButPartResult();
-        }
         return getResolvedLibrary(file.path);
       },
       (externalLibrary) async {
@@ -996,23 +1000,6 @@
     return completer.future;
   }
 
-  /// Return `true` is the file with the given absolute [uri] is a library,
-  /// or `false` if it is a part. More specifically, return `true` if the file
-  /// is not known to be a part.
-  ///
-  /// Correspondingly, return `true` if the [uri] does not correspond to a file,
-  /// for any reason, e.g. the file does not exist, or the [uri] cannot be
-  /// resolved to a file path, or the [uri] is invalid, e.g. a `package:` URI
-  /// without a package name. In these cases we cannot prove that the file is
-  /// not a part, so it must be a library.
-  bool isLibraryByUri(Uri uri) {
-    var fileOr = _fsState.getFileForUri(uri);
-    return fileOr.map(
-      (file) => file == null || !file.isPart,
-      (uri) => false,
-    );
-  }
-
   /// Return a [Future] that completes with a [ParsedUnitResult] for the file
   /// with the given [path].
   ///
diff --git a/pkg/analyzer/lib/src/dart/micro/resolve_file.dart b/pkg/analyzer/lib/src/dart/micro/resolve_file.dart
index 198bb5b..3b94d9b 100644
--- a/pkg/analyzer/lib/src/dart/micro/resolve_file.dart
+++ b/pkg/analyzer/lib/src/dart/micro/resolve_file.dart
@@ -42,9 +42,6 @@
 import 'package:meta/meta.dart';
 import 'package:yaml/yaml.dart';
 
-const M = 1024 * 1024 /*1 MiB*/;
-const memoryCacheSize = 200 * M;
-
 class CiderSearchInfo {
   final CharacterLocation startPosition;
   final int length;
@@ -129,24 +126,18 @@
   @visibleForTesting
   final Map<String, ResolvedLibraryResult> cachedResults = {};
 
-  FileResolver(
-    PerformanceLog logger,
-    ResourceProvider resourceProvider,
-    SourceFactory sourceFactory,
-    String Function(String path) getFileDigest,
-    void Function(List<String> paths)? prefetchFiles, {
-    required Workspace workspace,
-    bool Function(String path)? isGenerated,
-  }) : this.from(
-          logger: logger,
-          resourceProvider: resourceProvider,
-          sourceFactory: sourceFactory,
-          getFileDigest: getFileDigest,
-          prefetchFiles: prefetchFiles,
-          workspace: workspace,
-          isGenerated: isGenerated,
-        );
+  FileResolver({
+    required this.logger,
+    required this.resourceProvider,
+    required this.sourceFactory,
+    required this.getFileDigest,
+    required this.prefetchFiles,
+    required this.workspace,
+    this.isGenerated,
+    required this.byteStore,
+  });
 
+  @Deprecated('Use the unnamed constructor instead')
   FileResolver.from({
     required this.logger,
     required this.resourceProvider,
@@ -155,8 +146,8 @@
     required this.prefetchFiles,
     required this.workspace,
     this.isGenerated,
-    CiderByteStore? byteStore,
-  }) : byteStore = byteStore ?? CiderCachedByteStore(memoryCacheSize);
+    required this.byteStore,
+  });
 
   /// Update the resolver to reflect the fact that the file with the given
   /// [path] was changed. We need to make sure that when this file, of any file
diff --git a/pkg/analyzer/test/src/dart/analysis/driver_test.dart b/pkg/analyzer/test/src/dart/analysis/driver_test.dart
index 7cc3008..ca5fff1 100644
--- a/pkg/analyzer/test/src/dart/analysis/driver_test.dart
+++ b/pkg/analyzer/test/src/dart/analysis/driver_test.dart
@@ -35,6 +35,7 @@
   defineReflectiveSuite(() {
     defineReflectiveTests(AnalysisDriverSchedulerTest);
     defineReflectiveTests(AnalysisDriverTest);
+    defineReflectiveTests(AnalysisDriver_PubPackageTest);
     defineReflectiveTests(AnalysisDriver_BazelWorkspaceTest);
   });
 }
@@ -102,6 +103,135 @@
 }
 
 @reflectiveTest
+class AnalysisDriver_PubPackageTest extends PubPackageResolutionTest {
+  test_getLibraryByUri_cannotResolveUri() async {
+    final driver = driverFor(testFile.path);
+    expect(
+      await driver.getLibraryByUri('foo:bar'),
+      isA<CannotResolveUriResult>(),
+    );
+  }
+
+  test_getLibraryByUri_notLibrary_augmentation() async {
+    final a = newFile('$testPackageLibPath/a.dart', r'''
+library augment 'b.dart';
+''');
+
+    final driver = driverFor(a.path);
+    expect(
+      await driver.getLibraryByUri('package:test/a.dart'),
+      isA<NotLibraryButAugmentationResult>(),
+    );
+  }
+
+  test_getLibraryByUri_notLibrary_part() async {
+    final a = newFile('$testPackageLibPath/a.dart', r'''
+part of 'b.dart';
+''');
+
+    final driver = driverFor(a.path);
+    expect(
+      await driver.getLibraryByUri('package:test/a.dart'),
+      isA<NotLibraryButPartResult>(),
+    );
+  }
+
+  test_getParsedLibraryByUri_cannotResolveUri() async {
+    final driver = driverFor(testFile.path);
+    final uri = Uri.parse('foo:bar');
+    expect(
+      driver.getParsedLibraryByUri(uri),
+      isA<CannotResolveUriResult>(),
+    );
+  }
+
+  test_getParsedLibraryByUri_notLibrary_augmentation() async {
+    final a = newFile('$testPackageLibPath/a.dart', r'''
+library augment 'b.dart';
+''');
+
+    final driver = driverFor(a.path);
+    final uri = Uri.parse('package:test/a.dart');
+    expect(
+      driver.getParsedLibraryByUri(uri),
+      isA<NotLibraryButAugmentationResult>(),
+    );
+  }
+
+  test_getParsedLibraryByUri_notLibrary_part() async {
+    final a = newFile('$testPackageLibPath/a.dart', r'''
+part of 'b.dart';
+''');
+
+    final driver = driverFor(a.path);
+    final uri = Uri.parse('package:test/a.dart');
+    expect(
+      driver.getParsedLibraryByUri(uri),
+      isA<NotLibraryButPartResult>(),
+    );
+  }
+
+  test_getResolvedLibrary_notLibrary_augmentation() async {
+    final a = newFile('$testPackageLibPath/a.dart', r'''
+library augment 'b.dart';
+''');
+
+    final driver = driverFor(a.path);
+    expect(
+      await driver.getResolvedLibrary(a.path),
+      isA<NotLibraryButAugmentationResult>(),
+    );
+  }
+
+  test_getResolvedLibrary_notLibrary_part() async {
+    final a = newFile('$testPackageLibPath/a.dart', r'''
+part of 'b.dart';
+''');
+
+    final driver = driverFor(a.path);
+    expect(
+      await driver.getResolvedLibrary(a.path),
+      isA<NotLibraryButPartResult>(),
+    );
+  }
+
+  test_getResolvedLibraryByUri_cannotResolveUri() async {
+    final driver = driverFor(testFile.path);
+    final uri = Uri.parse('foo:bar');
+    expect(
+      await driver.getResolvedLibraryByUri(uri),
+      isA<CannotResolveUriResult>(),
+    );
+  }
+
+  test_getResolvedLibraryByUri_notLibrary_augmentation() async {
+    final a = newFile('$testPackageLibPath/a.dart', r'''
+library augment 'b.dart';
+''');
+
+    final driver = driverFor(a.path);
+    final uri = Uri.parse('package:test/a.dart');
+    expect(
+      await driver.getResolvedLibraryByUri(uri),
+      isA<NotLibraryButAugmentationResult>(),
+    );
+  }
+
+  test_getResolvedLibraryByUri_notLibrary_part() async {
+    final a = newFile('$testPackageLibPath/a.dart', r'''
+part of 'b.dart';
+''');
+
+    final driver = driverFor(a.path);
+    final uri = Uri.parse('package:test/a.dart');
+    expect(
+      await driver.getResolvedLibraryByUri(uri),
+      isA<NotLibraryButPartResult>(),
+    );
+  }
+}
+
+@reflectiveTest
 class AnalysisDriverSchedulerTest with ResourceProviderMixin {
   final ByteStore byteStore = MemoryByteStore();
 
@@ -2329,16 +2459,6 @@
     await waitForIdleWithoutExceptions();
   }
 
-  test_isLibraryByUri_doesNotExist() async {
-    var uri = Uri.parse('file:///test.dart');
-    expect(driver.isLibraryByUri(uri), isTrue);
-  }
-
-  test_isLibraryByUri_invalidUri() async {
-    var uri = Uri.parse('package:aaa');
-    expect(driver.isLibraryByUri(uri), isTrue);
-  }
-
   test_issue34619() async {
     var a = convertPath('/test/lib/a.dart');
     newFile(a, r'''
diff --git a/pkg/analyzer/test/src/dart/analysis/session_test.dart b/pkg/analyzer/test/src/dart/analysis/session_test.dart
index ee74d7f..3a7a851 100644
--- a/pkg/analyzer/test/src/dart/analysis/session_test.dart
+++ b/pkg/analyzer/test/src/dart/analysis/session_test.dart
@@ -268,6 +268,26 @@
     );
   }
 
+  test_getLibraryByUri_notLibrary_augmentation() async {
+    newFile(testFilePath, r'''
+library augment 'a.dart';
+''');
+
+    final session = contextFor(testFilePath).currentSession;
+    final result = await session.getLibraryByUri('package:test/test.dart');
+    expect(result, isA<NotLibraryButAugmentationResult>());
+  }
+
+  test_getLibraryByUri_notLibrary_part() async {
+    newFile(testFilePath, r'''
+part of 'a.dart';
+''');
+
+    final session = contextFor(testFilePath).currentSession;
+    final result = await session.getLibraryByUri('package:test/test.dart');
+    expect(result, isA<NotLibraryButPartResult>());
+  }
+
   test_getLibraryByUri_unresolvedUri() async {
     var session = contextFor(testFilePath).currentSession;
     var result = await session.getLibraryByUri('package:foo/foo.dart');
@@ -402,6 +422,16 @@
     expect(session.getParsedLibrary(test.path), isA<NotLibraryButPartResult>());
   }
 
+  test_getParsedLibrary_notLibrary_augmentation() async {
+    newFile(testFilePath, r'''
+library augment 'a.dart';
+''');
+
+    final session = contextFor(testFilePath).currentSession;
+    final result = session.getParsedLibrary(testFilePath);
+    expect(result, isA<NotLibraryButAugmentationResult>());
+  }
+
   test_getParsedLibrary_parts() async {
     var aContent = r'''
 part 'b.dart';
@@ -661,7 +691,17 @@
     expect(result, isA<InvalidPathResult>());
   }
 
-  test_getResolvedLibrary_notLibrary() async {
+  test_getResolvedLibrary_notLibrary_augmentation() async {
+    newFile(testFilePath, r'''
+library augment of 'a.dart';
+''');
+
+    final session = contextFor(testFilePath).currentSession;
+    final result = await session.getResolvedLibrary(testFilePath);
+    expect(result, isA<NotLibraryButAugmentationResult>());
+  }
+
+  test_getResolvedLibrary_notLibrary_part() async {
     var test = newFile(testFilePath, 'part of "a.dart";');
 
     var session = contextFor(testFilePath).currentSession;
diff --git a/pkg/analyzer/test/src/dart/micro/file_resolution.dart b/pkg/analyzer/test/src/dart/micro/file_resolution.dart
index 51c7429..d9c67b6 100644
--- a/pkg/analyzer/test/src/dart/micro/file_resolution.dart
+++ b/pkg/analyzer/test/src/dart/micro/file_resolution.dart
@@ -50,7 +50,7 @@
     )!;
 
     byteStore.testView = CiderByteStoreTestView();
-    fileResolver = FileResolver.from(
+    fileResolver = FileResolver(
       logger: logger,
       resourceProvider: resourceProvider,
       byteStore: byteStore,
diff --git a/pkg/compiler/test/analyses/dart2js_allowed.json b/pkg/compiler/test/analyses/dart2js_allowed.json
index 2d86d0b..4ae46c3 100644
--- a/pkg/compiler/test/analyses/dart2js_allowed.json
+++ b/pkg/compiler/test/analyses/dart2js_allowed.json
@@ -104,11 +104,10 @@
     "Dynamic access of 'index'.": 1
   },
   "pkg/dart2js_info/lib/src/util.dart": {
-    "Dynamic access of 'name'.": 1,
     "Dynamic invocation of '-'.": 1
   },
   "pkg/js_ast/lib/src/template.dart": {
     "Dynamic invocation of '[]'.": 9,
     "Dynamic invocation of 'toStatement'.": 1
   }
-}
\ No newline at end of file
+}
diff --git a/pkg/dart2js_info/lib/src/util.dart b/pkg/dart2js_info/lib/src/util.dart
index f509ea6..48bb5d1 100644
--- a/pkg/dart2js_info/lib/src/util.dart
+++ b/pkg/dart2js_info/lib/src/util.dart
@@ -74,7 +74,7 @@
   final infoPath = <Info>[];
   Info? localInfo = info;
   while (localInfo != null) {
-    infoPath.add(info);
+    infoPath.add(localInfo);
     localInfo = localInfo.parent;
   }
   var sb = StringBuffer();
diff --git a/runtime/vm/message_snapshot.cc b/runtime/vm/message_snapshot.cc
index 48f6aec..a24ad62 100644
--- a/runtime/vm/message_snapshot.cc
+++ b/runtime/vm/message_snapshot.cc
@@ -2848,7 +2848,7 @@
     const intptr_t count = d->ReadUnsigned();
     for (intptr_t i = 0; i < count; i++) {
       intptr_t length = d->ReadUnsigned();
-      d->AssignRef(Array::New(cid_, length));
+      d->AssignRef(Array::NewUninitialized(cid_, length));
     }
   }
 
diff --git a/runtime/vm/object.cc b/runtime/vm/object.cc
index 46d3e1b..52de6b1 100644
--- a/runtime/vm/object.cc
+++ b/runtime/vm/object.cc
@@ -2638,7 +2638,21 @@
         initial_value |= initial_value << 32;
       }
 #endif
-      needs_init = true;
+      if (class_id == kArrayCid) {
+        // If the size is greater than both kNewAllocatableSize and
+        // kAllocatablePageSize, the object must have been allocated to a new
+        // large page, which must already have been zero initialized by the OS.
+        // Zero is a GC-safe value. The caller will initialize the fields to
+        // null with safepoint checks to avoid blocking for the full duration of
+        // initializing this array.
+        needs_init = Heap::IsAllocatableInNewSpace(size) ||
+                     Heap::IsAllocatableViaFreeLists(size);
+        if (!needs_init) {
+          initial_value = 0;  // For ASSERT below.
+        }
+      } else {
+        needs_init = true;
+      }
     }
     if (needs_init) {
       while (cur < end) {
@@ -24321,17 +24335,6 @@
   return hash;
 }
 
-ArrayPtr Array::New(intptr_t len, Heap::Space space) {
-  ASSERT(IsolateGroup::Current()->object_store()->array_class() !=
-         Class::null());
-  ArrayPtr result = New(kClassId, len, space);
-  if (UseCardMarkingForAllocation(len)) {
-    ASSERT(result->IsOldObject());
-    result->untag()->SetCardRememberedBitUnsynchronized();
-  }
-  return result;
-}
-
 ArrayPtr Array::New(intptr_t len,
                     const AbstractType& element_type,
                     Heap::Space space) {
@@ -24345,7 +24348,9 @@
   return result.ptr();
 }
 
-ArrayPtr Array::New(intptr_t class_id, intptr_t len, Heap::Space space) {
+ArrayPtr Array::NewUninitialized(intptr_t class_id,
+                                 intptr_t len,
+                                 Heap::Space space) {
   if (!IsValidLength(len)) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in Array::New: invalid len %" Pd "\n", len);
@@ -24356,23 +24361,56 @@
                          Array::ContainsCompressedPointers()));
     NoSafepointScope no_safepoint;
     raw->untag()->set_length(Smi::New(len));
+    if (UseCardMarkingForAllocation(len)) {
+      ASSERT(raw->IsOldObject());
+      raw->untag()->SetCardRememberedBitUnsynchronized();
+    }
     return raw;
   }
 }
 
+ArrayPtr Array::New(intptr_t class_id, intptr_t len, Heap::Space space) {
+  if (!UseCardMarkingForAllocation(len)) {
+    return NewUninitialized(class_id, len, space);
+  }
+
+  Thread* thread = Thread::Current();
+  Array& result =
+      Array::Handle(thread->zone(), NewUninitialized(class_id, len, space));
+  result.SetTypeArguments(Object::null_type_arguments());
+  for (intptr_t i = 0; i < len; i++) {
+    result.SetAt(i, Object::null_object(), thread);
+    if (((i + 1) % KB) == 0) {
+      thread->CheckForSafepoint();
+    }
+  }
+  return result.ptr();
+}
+
 ArrayPtr Array::Slice(intptr_t start,
                       intptr_t count,
                       bool with_type_argument) const {
-  // TODO(vegorov) introduce an array allocation method that fills newly
-  // allocated array with values from the given source array instead of
-  // null-initializing all elements.
-  Array& dest = Array::Handle(Array::New(count));
-  dest.StoreArrayPointers(dest.ObjectAddr(0), ObjectAddr(start), count);
-
+  Thread* thread = Thread::Current();
+  Zone* zone = thread->zone();
+  const Array& dest = Array::Handle(zone, Array::NewUninitialized(count));
   if (with_type_argument) {
-    dest.SetTypeArguments(TypeArguments::Handle(GetTypeArguments()));
+    dest.SetTypeArguments(TypeArguments::Handle(zone, GetTypeArguments()));
+  } else {
+    dest.SetTypeArguments(Object::null_type_arguments());
   }
-
+  if (!UseCardMarkingForAllocation(count)) {
+    NoSafepointScope no_safepoint(thread);
+    for (int i = 0; i < count; i++) {
+      dest.untag()->set_element(i, untag()->element(i + start), thread);
+    }
+  } else {
+    for (int i = 0; i < count; i++) {
+      dest.untag()->set_element(i, untag()->element(i + start), thread);
+      if (((i + 1) % KB) == 0) {
+        thread->CheckForSafepoint();
+      }
+    }
+  }
   return dest.ptr();
 }
 
@@ -24397,19 +24435,30 @@
                      Heap::Space space) {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
-  const Array& result = Array::Handle(zone, Array::New(new_length, space));
+  const Array& result =
+      Array::Handle(zone, Array::NewUninitialized(new_length, space));
   intptr_t len = 0;
   if (!source.IsNull()) {
     len = source.Length();
     result.SetTypeArguments(
         TypeArguments::Handle(zone, source.GetTypeArguments()));
+  } else {
+    result.SetTypeArguments(Object::null_type_arguments());
   }
   ASSERT(new_length >= len);  // Cannot copy 'source' into new array.
   ASSERT(new_length != len);  // Unnecessary copying of array.
-  PassiveObject& obj = PassiveObject::Handle(zone);
-  for (int i = 0; i < len; i++) {
-    obj = source.At(i);
-    result.SetAt(i, obj, thread);
+  if (!UseCardMarkingForAllocation(len)) {
+    NoSafepointScope no_safepoint(thread);
+    for (int i = 0; i < len; i++) {
+      result.untag()->set_element(i, source.untag()->element(i), thread);
+    }
+  } else {
+    for (int i = 0; i < len; i++) {
+      result.untag()->set_element(i, source.untag()->element(i), thread);
+      if (((i + 1) % KB) == 0) {
+        thread->CheckForSafepoint();
+      }
+    }
   }
   return result.ptr();
 }
diff --git a/runtime/vm/object.h b/runtime/vm/object.h
index 6f226c3..17080ec 100644
--- a/runtime/vm/object.h
+++ b/runtime/vm/object.h
@@ -10419,7 +10419,15 @@
   // to ImmutableArray.
   void MakeImmutable() const;
 
-  static ArrayPtr New(intptr_t len, Heap::Space space = Heap::kNew);
+  static ArrayPtr New(intptr_t len, Heap::Space space = Heap::kNew) {
+    return New(kArrayCid, len, space);
+  }
+  // The result's type arguments and elements are GC-safe but not initialized to
+  // null.
+  static ArrayPtr NewUninitialized(intptr_t len,
+                                   Heap::Space space = Heap::kNew) {
+    return NewUninitialized(kArrayCid, len, space);
+  }
   static ArrayPtr New(intptr_t len,
                       const AbstractType& element_type,
                       Heap::Space space = Heap::kNew);
@@ -10457,6 +10465,9 @@
   static ArrayPtr New(intptr_t class_id,
                       intptr_t len,
                       Heap::Space space = Heap::kNew);
+  static ArrayPtr NewUninitialized(intptr_t class_id,
+                                   intptr_t len,
+                                   Heap::Space space = Heap::kNew);
 
  private:
   CompressedObjectPtr const* ObjectAddr(intptr_t index) const {
@@ -10477,25 +10488,6 @@
     ptr()->untag()->StoreArrayPointer<type, order, value_type>(addr, value);
   }
 
-  // Store a range of pointers [from, from + count) into [to, to + count).
-  // TODO(koda): Use this to fix Object::Clone's broken store buffer logic.
-  void StoreArrayPointers(CompressedObjectPtr const* to,
-                          CompressedObjectPtr const* from,
-                          intptr_t count) {
-    ASSERT(Contains(reinterpret_cast<uword>(to)));
-    if (ptr()->IsNewObject()) {
-      memmove(const_cast<CompressedObjectPtr*>(to), from,
-              count * kBytesPerElement);
-    } else {
-      Thread* thread = Thread::Current();
-      const uword heap_base = ptr()->heap_base();
-      for (intptr_t i = 0; i < count; ++i) {
-        untag()->StoreArrayPointer(&to[i], from[i].Decompress(heap_base),
-                                   thread);
-      }
-    }
-  }
-
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Array, Instance);
   friend class Class;
   friend class ImmutableArray;
diff --git a/runtime/vm/object_graph_copy.cc b/runtime/vm/object_graph_copy.cc
index 43c35b3..560a7a7 100644
--- a/runtime/vm/object_graph_copy.cc
+++ b/runtime/vm/object_graph_copy.cc
@@ -471,27 +471,30 @@
  public:
   explicit SlowForwardMap(Thread* thread)
       : ForwardMapBase(thread),
-        from_to_(thread->zone(), 20),
+        from_to_transition_(thread->zone(), 2),
+        from_to_(GrowableObjectArray::Handle(thread->zone(),
+                                             GrowableObjectArray::New(2))),
         transferables_from_to_(thread->zone(), 0) {
-    from_to_.Resize(2);
-    from_to_[0] = &Object::null_object();
-    from_to_[1] = &Object::null_object();
+    from_to_transition_.Resize(2);
+    from_to_transition_[0] = &PassiveObject::Handle();
+    from_to_transition_[1] = &PassiveObject::Handle();
+    from_to_.Add(Object::null_object());
+    from_to_.Add(Object::null_object());
     fill_cursor_ = 2;
   }
 
   ObjectPtr ForwardedObject(ObjectPtr object) {
     const intptr_t id = GetObjectId(object);
     if (id == 0) return Marker();
-    return from_to_[id + 1]->ptr();
+    return from_to_.At(id + 1);
   }
 
-  void Insert(ObjectPtr from, ObjectPtr to, intptr_t size) {
-    ASSERT(ForwardedObject(from) == Marker());
-    const auto id = from_to_.length();
-    SetObjectId(from, id);
-    from_to_.Resize(id + 2);
-    from_to_[id] = &Object::Handle(Z, from);
-    from_to_[id + 1] = &Object::Handle(Z, to);
+  void Insert(const Object& from, const Object& to, intptr_t size) {
+    ASSERT(ForwardedObject(from.ptr()) == Marker());
+    const auto id = from_to_.Length();
+    SetObjectId(from.ptr(), id);
+    from_to_.Add(from);
+    from_to_.Add(to);
     allocated_bytes += size;
   }
 
@@ -537,7 +540,8 @@
   friend class SlowObjectCopy;
   friend class ObjectGraphCopier;
 
-  GrowableArray<const Object*> from_to_;
+  GrowableArray<const PassiveObject*> from_to_transition_;
+  GrowableObjectArray& from_to_;
   GrowableArray<const TransferableTypedData*> transferables_from_to_;
   GrowableArray<const ExternalTypedData*> external_typed_data_;
   GrowableArray<const Object*> objects_to_rehash_;
@@ -560,6 +564,7 @@
         class_table_(thread->isolate_group()->class_table()),
         new_space_(heap_->new_space()),
         tmp_(Object::Handle(thread->zone())),
+        to_(Object::Handle(thread->zone())),
         expando_cid_(Class::GetClassId(
             thread->isolate_group()->object_store()->expando_class())) {}
   ~ObjectCopyBase() {}
@@ -681,6 +686,7 @@
   ClassTable* class_table_;
   Scavenger* new_space_;
   Object& tmp_;
+  Object& to_;
   intptr_t expando_cid_;
 
   const char* exception_msg_ = nullptr;
@@ -990,9 +996,10 @@
     if (size == 0) {
       size = from.ptr().untag()->HeapSize();
     }
-    ObjectPtr to = AllocateObject(cid, size);
-    slow_forward_map_.Insert(from.ptr(), to, size);
-    UpdateLengthField(cid, from.ptr(), to);
+    to_ = AllocateObject(cid, size);
+    UpdateLengthField(cid, from.ptr(), to_.ptr());
+    slow_forward_map_.Insert(from, to_, size);  // SAFEPOINT
+    ObjectPtr to = to_.ptr();
     if (cid == kArrayCid && !Heap::IsAllocatableInNewSpace(size)) {
       to.untag()->SetCardRememberedBitUnsynchronized();
     }
@@ -1678,16 +1685,16 @@
     Object& to = Object::Handle(Z);
     while (true) {
       if (slow_forward_map_.fill_cursor_ ==
-          slow_forward_map_.from_to_.length()) {
+          slow_forward_map_.from_to_.Length()) {
         break;
       }
 
       // Run fixpoint to copy all objects.
       while (slow_forward_map_.fill_cursor_ <
-             slow_forward_map_.from_to_.length()) {
+             slow_forward_map_.from_to_.Length()) {
         const intptr_t index = slow_forward_map_.fill_cursor_;
-        from = slow_forward_map_.from_to_[index]->ptr();
-        to = slow_forward_map_.from_to_[index + 1]->ptr();
+        from = slow_forward_map_.from_to_.At(index);
+        to = slow_forward_map_.from_to_.At(index + 1);
         CopyObject(from, to);
         slow_forward_map_.fill_cursor_ += 2;
         if (exception_msg_ != nullptr) {
@@ -1915,6 +1922,8 @@
                                            /*compact=*/true);
       }
 
+      ObjectifyFromToObjects();
+
       // Fast copy failed due to
       //   - either failure to allocate into new space
       //   - or failure to copy object which we cannot copy
@@ -2021,20 +2030,28 @@
   void HandlifyFromToObjects() {
     auto& fast_forward_map = fast_object_copy_.fast_forward_map_;
     auto& slow_forward_map = slow_object_copy_.slow_forward_map_;
-
-    const intptr_t cursor = fast_forward_map.fill_cursor_;
     const intptr_t length = fast_forward_map.raw_from_to_.length();
-
-    slow_forward_map.from_to_.Resize(length);
-    for (intptr_t i = 2; i < length; i += 2) {
-      slow_forward_map.from_to_[i] =
-          i < cursor ? nullptr
-                     : &Object::Handle(Z, fast_forward_map.raw_from_to_[i]);
-      slow_forward_map.from_to_[i + 1] =
-          &Object::Handle(Z, fast_forward_map.raw_from_to_[i + 1]);
+    slow_forward_map.from_to_transition_.Resize(length);
+    for (intptr_t i = 0; i < length; i++) {
+      slow_forward_map.from_to_transition_[i] =
+          &PassiveObject::Handle(Z, fast_forward_map.raw_from_to_[i]);
     }
+    ASSERT(slow_forward_map.from_to_transition_.length() == length);
     fast_forward_map.raw_from_to_.Clear();
   }
+  void ObjectifyFromToObjects() {
+    auto& from_to_transition =
+        slow_object_copy_.slow_forward_map_.from_to_transition_;
+    auto& from_to = slow_object_copy_.slow_forward_map_.from_to_;
+    intptr_t length = from_to_transition.length();
+    from_to = GrowableObjectArray::New(length, Heap::kOld);
+    for (intptr_t i = 0; i < length; i++) {
+      from_to.Add(*from_to_transition[i]);
+    }
+    ASSERT(from_to.Length() == length);
+    from_to_transition.Clear();
+  }
+
   void ThrowException(const char* exception_msg) {
     const auto& msg_obj = String::Handle(Z, String::New(exception_msg));
     const auto& args = Array::Handle(Z, Array::New(1));
diff --git a/tools/VERSION b/tools/VERSION
index ca2aee4..02213d8 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 18
 PATCH 0
-PRERELEASE 161
+PRERELEASE 162
 PRERELEASE_PATCH 0
\ No newline at end of file