diff --git a/pkg/_fe_analyzer_shared/pubspec.yaml b/pkg/_fe_analyzer_shared/pubspec.yaml
index e8855e1..4a30fc7 100644
--- a/pkg/_fe_analyzer_shared/pubspec.yaml
+++ b/pkg/_fe_analyzer_shared/pubspec.yaml
@@ -1,5 +1,5 @@
 name: _fe_analyzer_shared
-version: 38.0.0
+version: 39.0.0
 description: Logic that is shared between the front_end and analyzer packages.
 homepage: https://github.com/dart-lang/sdk/tree/master/pkg/_fe_analyzer_shared
 
diff --git a/pkg/analysis_server/lib/src/services/completion/dart/suggestion_builder.dart b/pkg/analysis_server/lib/src/services/completion/dart/suggestion_builder.dart
index bf2dee5..689dd80 100644
--- a/pkg/analysis_server/lib/src/services/completion/dart/suggestion_builder.dart
+++ b/pkg/analysis_server/lib/src/services/completion/dart/suggestion_builder.dart
@@ -752,11 +752,9 @@
     );
   }
 
-  /// Add a suggestion for a [method]. If the method is being invoked with a
-  /// target of `super`, then the [containingMemberName] should be the name of
-  /// the member containing the invocation. If a [kind] is provided it will be
-  /// used as the kind for the suggestion. The [inheritanceDistance] is the
-  /// value of the inheritance distance feature computed for the method.
+  /// Add a suggestion for a [method]. If a [kind] is provided it will be used
+  /// as the kind for the suggestion. The [inheritanceDistance] is the value of
+  /// the inheritance distance feature computed for the method.
   void suggestMethod(MethodElement method,
       {required CompletionSuggestionKind kind,
       required double inheritanceDistance}) {
@@ -1047,10 +1045,8 @@
     );
   }
 
-  /// Add a suggestion for a top-level property [accessor]. If a [kind] is
-  /// provided it will be used as the kind for the suggestion. If the accessor
-  /// can only be referenced using a prefix, then the [prefix] should be
-  /// provided.
+  /// Add a suggestion for a top-level property [accessor]. If the accessor can
+  /// only be referenced using a prefix, then the [prefix] should be provided.
   void suggestTopLevelPropertyAccessor(PropertyAccessorElement accessor,
       {String? prefix}) {
     assert(
@@ -1102,8 +1098,7 @@
     }
   }
 
-  /// Add a suggestion for a top-level [variable]. If a [kind] is provided it
-  /// will be used as the kind for the suggestion. If the variable can only be
+  /// Add a suggestion for a top-level [variable]. If the variable can only be
   /// referenced using a prefix, then the [prefix] should be provided.
   void suggestTopLevelVariable(TopLevelVariableElement variable,
       {String? prefix}) {
@@ -1121,9 +1116,8 @@
     );
   }
 
-  /// Add a suggestion for a [typeAlias]. If a [kind] is provided it
-  /// will be used as the kind for the suggestion. If the alias can only be
-  /// referenced using a prefix, then the [prefix] should be provided.
+  /// Add a suggestion for a [typeAlias]. If the alias can only be referenced
+  /// using a prefix, then the [prefix] should be provided.
   void suggestTypeAlias(TypeAliasElement typeAlias, {String? prefix}) {
     var relevance = _computeTopLevelRelevance(typeAlias,
         elementType: _instantiateTypeAlias(typeAlias));
diff --git a/pkg/analysis_server/test/tool/completion_metrics/metrics_util_test.dart b/pkg/analysis_server/test/tool/completion_metrics/metrics_util_test.dart
index 639b3eb..9702d0e 100644
--- a/pkg/analysis_server/test/tool/completion_metrics/metrics_util_test.dart
+++ b/pkg/analysis_server/test/tool/completion_metrics/metrics_util_test.dart
@@ -161,6 +161,57 @@
     });
   });
 
+  group('PercentileComputer', () {
+    test('empty', () {
+      var computer = PercentileComputer('empty', valueLimit: 2000);
+      expect(computer.median, equals(0));
+      expect(computer.valueCount, equals(0));
+    });
+
+    test('clear', () {
+      var computer = PercentileComputer('name', valueLimit: 2000);
+      computer.addValue(4);
+      computer.addValue(5);
+      computer.addValue(6);
+      computer.addValue(3000);
+
+      expect(computer.median, equals(5));
+      expect(computer.valueCount, equals(3));
+      expect(computer.aboveValueMaxCount, equals(1));
+      computer.clear();
+
+      expect(computer.median, equals(0));
+      expect(computer.valueCount, equals(0));
+      expect(computer.aboveValueMaxCount, equals(0));
+      expect(computer.aboveValueMaxSamples, isEmpty);
+    });
+
+    test('percentiles', () {
+      var computer = PercentileComputer('name', valueLimit: 2000);
+      for (var i = 0; i < 100; i++) {
+        computer.addValue(i);
+      }
+
+      expect(computer.median, equals(50));
+      expect(computer.p90, equals(90));
+      expect(computer.p95, equals(95));
+    });
+
+    test('values above maxValue', () {
+      var computer = PercentileComputer('name', valueLimit: 2000);
+
+      computer.addValue(1);
+      computer.addValue(2);
+      computer.addValue(3);
+      computer.addValue(2500);
+      computer.addValue(3000);
+
+      expect(computer.median, equals(2));
+      expect(computer.aboveValueMaxCount, equals(2));
+      expect(computer.aboveValueMaxSamples, equals([2500, 3000]));
+    });
+  });
+
   group('Place', () {
     test('none', () {
       var place = Place.none();
diff --git a/pkg/analysis_server/tool/code_completion/completion_metrics.dart b/pkg/analysis_server/tool/code_completion/completion_metrics.dart
index fcc4650..ed88f0c 100644
--- a/pkg/analysis_server/tool/code_completion/completion_metrics.dart
+++ b/pkg/analysis_server/tool/code_completion/completion_metrics.dart
@@ -66,10 +66,13 @@
 ///
 /// This approach has several drawbacks:
 ///
-/// - The AST is always complete and correct, and that's rarely the case for
-///   real completion requests. Usually the tree is incomplete and often has a
-///   completely different structure because of the way recovery works. We
-///   currently have no way of measuring completions under realistic conditions.
+/// - The options for creating an "in-progress" file are limited. In the default
+///   'overlay' mode, the AST is always complete and correct, rarely the case
+///   for real completion requests. The other 'overlay' modes generate
+///   incomplete ASTs with error recovery nodes, but neither of these quite
+///   properly emulate the act of editing the middle of a file, perhaps the
+///   middle of an expression, or the middle of an argument list. We currently
+///   have no way of measuring completions under realistic conditions.
 ///
 /// - We can't measure completions for several keywords because the presence of
 ///   the keyword in the AST causes it to not be suggested.
@@ -77,7 +80,7 @@
 /// - The time it takes to compute the suggestions doesn't include the time
 ///   required to finish analyzing the file if the analysis hasn't been
 ///   completed before suggestions are requested. While the times are accurate
-///   (within the accuracy of the `Stopwatch` class) they are the minimum
+///   (within the accuracy of the [Stopwatch] class) they are the minimum
 ///   possible time. This doesn't give us a measure of how completion will
 ///   perform in production, but does give us an optimistic approximation.
 ///
@@ -193,7 +196,7 @@
     ..addFlag(CompletionMetricsOptions.PRINT_SHADOWED_COMPLETION_DETAILS,
         defaultsTo: false,
         help: 'Print detailed information every time a completion request '
-            'produces a suggestions whose name matches the expected suggestion '
+            'produces a suggestion whose name matches the expected suggestion '
             'but that is referencing a different element',
         negatable: false)
     ..addFlag(CompletionMetricsOptions.PRINT_SLOWEST_RESULTS,
@@ -332,6 +335,11 @@
   final ArithmeticMeanComputer meanCompletionMS =
       ArithmeticMeanComputer('ms per completion');
 
+  /// A percentile computer for the ms per completion request, using 2.000
+  /// seconds as the max value to use in percentile calculations.
+  final PercentileComputer percentileCompletionMS =
+      PercentileComputer('ms per completion', valueLimit: 2000);
+
   final DistributionComputer distributionCompletionMS = DistributionComputer();
 
   final MeanReciprocalRankComputer mrrComputer =
@@ -398,6 +406,8 @@
         .fromJson(map['completionElementKindCounter'] as Map<String, dynamic>);
     metrics.meanCompletionMS
         .fromJson(map['meanCompletionMS'] as Map<String, dynamic>);
+    metrics.percentileCompletionMS
+        .fromJson(map['percentileMS'] as Map<String, dynamic>);
     metrics.distributionCompletionMS
         .fromJson(map['distributionCompletionMS'] as Map<String, dynamic>);
     metrics.mrrComputer.fromJson(map['mrrComputer'] as Map<String, dynamic>);
@@ -453,6 +463,7 @@
     completionKindCounter.addData(metrics.completionKindCounter);
     completionElementKindCounter.addData(metrics.completionElementKindCounter);
     meanCompletionMS.addData(metrics.meanCompletionMS);
+    percentileCompletionMS.addData(metrics.percentileCompletionMS);
     distributionCompletionMS.addData(metrics.distributionCompletionMS);
     mrrComputer.addData(metrics.mrrComputer);
     successfulMrrComputer.addData(metrics.successfulMrrComputer);
@@ -545,6 +556,7 @@
       'completionKindCounter': completionKindCounter.toJson(),
       'completionElementKindCounter': completionElementKindCounter.toJson(),
       'meanCompletionMS': meanCompletionMS.toJson(),
+      'percentileCompletionMS': percentileCompletionMS.toJson(),
       'distributionCompletionMS': distributionCompletionMS.toJson(),
       'mrrComputer': mrrComputer.toJson(),
       'successfulMrrComputer': successfulMrrComputer.toJson(),
@@ -617,6 +629,7 @@
   /// Record this elapsed ms count for the average ms count.
   void _recordTime(CompletionResult result) {
     meanCompletionMS.addValue(result.elapsedMS);
+    percentileCompletionMS.addValue(result.elapsedMS);
     distributionCompletionMS.addValue(result.elapsedMS);
   }
 
@@ -815,7 +828,7 @@
 
   void printComparisonOfCompletionCounts() {
     String toString(int count, int totalCount) {
-      return '$count (${printPercentage(count / totalCount, 2)})';
+      return '$count (${(count / totalCount).asPercentage(2)})';
     }
 
     var counters = targetMetrics.map((metrics) => metrics.completionCounter);
@@ -1093,25 +1106,45 @@
   }
 
   void printOtherMetrics(CompletionMetrics metrics) {
-    List<String> toRow(ArithmeticMeanComputer computer) {
-      var min = computer.min;
-      var mean = computer.mean.toStringAsFixed(6);
-      var max = computer.max;
-      return [computer.name, '$min, $mean, $max'];
+    List<String> meanComputingRow(ArithmeticMeanComputer computer) {
+      return [
+        computer.name,
+        computer.min!.toStringAsFixed(3),
+        computer.mean.toStringAsFixed(3),
+        computer.max!.toStringAsFixed(3),
+      ];
     }
 
     var table = [
-      toRow(metrics.meanCompletionMS),
-      toRow(metrics.charsBeforeTop),
-      toRow(metrics.charsBeforeTopFive),
-      toRow(metrics.insertionLengthTheoretical),
+      ['', 'min', 'mean', 'max'],
+      meanComputingRow(metrics.meanCompletionMS),
+      meanComputingRow(metrics.charsBeforeTop),
+      meanComputingRow(metrics.charsBeforeTopFive),
+      meanComputingRow(metrics.insertionLengthTheoretical),
     ];
     rightJustifyColumns(table, range(1, table[0].length));
 
     printHeading(2, 'Other metrics');
     printTable(table);
 
+    var percentileTable = [
+      ['', 'p50', 'p90', 'p95', 'count > 2s', 'max'],
+      [
+        metrics.percentileCompletionMS.name,
+        metrics.percentileCompletionMS.median.toString(),
+        metrics.percentileCompletionMS.p90.toString(),
+        metrics.percentileCompletionMS.p95.toString(),
+        metrics.percentileCompletionMS.aboveValueMaxCount.toString(),
+        metrics.percentileCompletionMS.maxValue.toString(),
+      ],
+    ];
+    rightJustifyColumns(percentileTable, range(1, percentileTable[1].length));
+
+    printHeading(3, 'Percentile metrics');
+    printTable(percentileTable);
+
     var distribution = metrics.distributionCompletionMS.displayString();
+    printHeading(3, 'Completion ms distribution');
     print('${metrics.name}: $distribution');
     print('');
   }
@@ -2083,6 +2116,12 @@
   }
 }
 
+extension on num {
+  String asPercentage([int fractionDigits = 1]) =>
+      '${(this * 100).toStringAsFixed(fractionDigits)}%'
+          .padLeft(4 + fractionDigits);
+}
+
 extension AvailableSuggestionsExtension on protocol.AvailableSuggestion {
   // TODO(jwren) I am not sure if we want CompletionSuggestionKind.INVOCATION in
   // call cases here, to iterate I need to figure out why this algorithm is
diff --git a/pkg/analysis_server/tool/code_completion/metrics_util.dart b/pkg/analysis_server/tool/code_completion/metrics_util.dart
index 673f1bb..8899842 100644
--- a/pkg/analysis_server/tool/code_completion/metrics_util.dart
+++ b/pkg/analysis_server/tool/code_completion/metrics_util.dart
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import 'dart:math' as math;
+import 'dart:typed_data';
 
 import 'package:analysis_server/src/status/pages.dart';
 
@@ -295,6 +296,136 @@
   }
 }
 
+/// A computer for calculating percentile-based metrics on a data set.
+///
+/// Specifically this tracks p50 (the median), p90, and p95.
+///
+/// See https://en.wikipedia.org/wiki/Percentile.
+class PercentileComputer {
+  final String name;
+
+  /// The value limit allowed by this computer.
+  ///
+  /// The computer can calculate percentile values for all data that range
+  /// between 0 and [valueLimit], exclusive.
+  int valueLimit;
+
+  /// An array of counts; the value at each index _i_ is the number of
+  /// occurrences of value _i_.
+  ///
+  /// Any values larger than [valueLimit] are not counted here.
+  Uint32List _counts;
+
+  /// The number of values which are less than [valueLimit].
+  int valueCount = 0;
+
+  /// The number of values greater than [valueLimit].
+  int aboveValueMaxCount = 0;
+
+  List<int> aboveValueMaxSamples = [];
+
+  int maxValue = 0;
+
+  PercentileComputer(this.name, {required this.valueLimit})
+      : _counts = Uint32List(valueLimit);
+
+  /// Calculates the median (p50) value.
+  int get median => kthPercentile(50);
+
+  /// Calculates the p90 value; the value at the 90th percentile of the data.
+  int get p90 => kthPercentile(90);
+
+  /// Calculates the p95 value; the value at the 95th percentile of the data.
+  int get p95 => kthPercentile(95);
+
+  /// Add the data from the given [computer] to this computer.
+  void addData(PercentileComputer computer) {
+    if (computer.valueLimit != valueLimit) {
+      throw UnsupportedError(
+          'Cannot combine two PercentileComputers with different valueLimit '
+          'values');
+    }
+    for (var i = 0; i < _counts.length; i++) {
+      _counts[i] += computer._counts[i];
+    }
+    valueCount += computer.valueCount;
+    aboveValueMaxCount += computer.aboveValueMaxCount;
+    for (var val in computer.aboveValueMaxSamples) {
+      if (aboveValueMaxSamples.length < 10) {
+        aboveValueMaxSamples.add(val);
+      }
+    }
+    maxValue = math.max(maxValue, computer.maxValue);
+  }
+
+  void addValue(int val) {
+    if (val > valueLimit) {
+      aboveValueMaxCount++;
+      if (aboveValueMaxSamples.length < 10) {
+        aboveValueMaxSamples.add(val);
+      }
+    } else {
+      _counts[val]++;
+      valueCount++;
+    }
+    maxValue = math.max(maxValue, val);
+  }
+
+  void clear() {
+    _counts = Uint32List(0);
+    valueCount = 0;
+    aboveValueMaxCount = 0;
+    aboveValueMaxSamples = [];
+    maxValue = 0;
+  }
+
+  /// Set the state of this computer to the state recorded in the decoded JSON
+  /// [map].
+  void fromJson(Map<String, dynamic> map) {
+    valueLimit = map['valueLimit'] as int;
+    _counts = Uint32List.fromList((map['counts'] as List<dynamic>).cast<int>());
+    valueCount = map['valueCount'] as int;
+    aboveValueMaxCount = map['aboveValueMaxCount'] as int;
+    aboveValueMaxSamples =
+        (map['aboveValueMaxSamples'] as List<dynamic>).cast<int>();
+    maxValue = map['maxValue'] as int;
+  }
+
+  /// Calculates the value at the _k_th percentile of the data.
+  int kthPercentile(int percentile) {
+    if (valueCount == 0) {
+      return 0;
+    }
+    // Linear walk through the data takes O([maxValue]) time. If this is too
+    // slow, a binary search can be implemented.
+    var targetIndex = valueCount * percentile / 100;
+    // The number of values represented by walking the counts.
+    var accumulation = 0;
+    for (var i = 0; i < _counts.length; i++) {
+      accumulation += _counts[i];
+      if (accumulation > targetIndex) {
+        // We've now accounted for [targetIndex] values, which includes the
+        // median value.
+        return i;
+      }
+    }
+    // The median value is in the very highest expected possible value.
+    return valueLimit;
+  }
+
+  /// Return a map used to represent this computer in a JSON structure.
+  Map<String, dynamic> toJson() {
+    return {
+      'counts': _counts,
+      'valueLimit': valueLimit,
+      'valueCount': valueCount,
+      'aboveValueMaxCount': aboveValueMaxCount,
+      'aboveValueMaxSamples': aboveValueMaxSamples,
+      'maxValue': maxValue,
+    };
+  }
+}
+
 /// An immutable class to represent the placement in some list, for example '2nd
 /// place out of 5'.
 class Place {
diff --git a/pkg/analyzer/CHANGELOG.md b/pkg/analyzer/CHANGELOG.md
index 5ff3292..85f3551 100644
--- a/pkg/analyzer/CHANGELOG.md
+++ b/pkg/analyzer/CHANGELOG.md
@@ -1,4 +1,4 @@
-## 4.0.0 (Not yet released - breaking changes)
+## 4.0.0
 * Removed deprecated `UriKind` and `Source.uriKind`.
 * Removed deprecated `LibraryElement.hasExtUri`.
 * Removed deprecated `LibraryElement.hasLoadLibraryFunction`.
diff --git a/pkg/analyzer/pubspec.yaml b/pkg/analyzer/pubspec.yaml
index e0b366d..fdeb71c 100644
--- a/pkg/analyzer/pubspec.yaml
+++ b/pkg/analyzer/pubspec.yaml
@@ -1,5 +1,5 @@
 name: analyzer
-version: 4.0.0-dev
+version: 4.0.0
 description: This package provides a library that performs static analysis of Dart code.
 homepage: https://github.com/dart-lang/sdk/tree/main/pkg/analyzer
 
@@ -7,7 +7,7 @@
   sdk: '>=2.14.0 <3.0.0'
 
 dependencies:
-  _fe_analyzer_shared: ^38.0.0
+  _fe_analyzer_shared: ^39.0.0
   collection: ^1.15.0
   convert: ^3.0.0
   crypto: ^3.0.0
diff --git a/pkg/frontend_server/lib/frontend_server.dart b/pkg/frontend_server/lib/frontend_server.dart
index 2a303b8..a2c2d4e 100644
--- a/pkg/frontend_server/lib/frontend_server.dart
+++ b/pkg/frontend_server/lib/frontend_server.dart
@@ -36,6 +36,7 @@
 import 'package:vm/incremental_compiler.dart' show IncrementalCompiler;
 import 'package:vm/kernel_front_end.dart';
 
+import 'src/binary_protocol.dart';
 import 'src/javascript_bundle.dart';
 import 'src/strong_components.dart';
 
@@ -114,6 +115,10 @@
           ' option',
       defaultsTo: 'org-dartlang-root',
       hide: true)
+  ..addOption('binary-protocol-address',
+      hide: true,
+      help: 'The server will establish TCP connection to this address, and'
+          ' will exchange binary requests and responses with the client.')
   ..addFlag('enable-http-uris',
       defaultsTo: false, hide: true, help: 'Enables support for http uris.')
   ..addFlag('verbose', help: 'Enables verbose output from the compiler.')
@@ -1421,6 +1426,12 @@
     }
   }
 
+  final binaryProtocolAddressStr = options['binary-protocol-address'];
+  if (binaryProtocolAddressStr is String) {
+    runBinaryProtocol(binaryProtocolAddressStr);
+    return 0;
+  }
+
   compiler ??= FrontendCompiler(output,
       printerFactory: binaryPrinterFactory,
       unsafePackageSerialization: options["unsafe-package-serialization"],
diff --git a/pkg/frontend_server/lib/src/binary_protocol.dart b/pkg/frontend_server/lib/src/binary_protocol.dart
new file mode 100644
index 0000000..25fc45d
--- /dev/null
+++ b/pkg/frontend_server/lib/src/binary_protocol.dart
@@ -0,0 +1,269 @@
+// 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.
+
+// @dart = 2.15
+import 'dart:async';
+import 'dart:io' as io;
+import 'dart:typed_data';
+
+import 'package:_fe_analyzer_shared/src/macros/compiler/request_channel.dart';
+import 'package:front_end/src/api_prototype/compiler_options.dart' as fe;
+import 'package:front_end/src/api_prototype/file_system.dart' as fe;
+import 'package:front_end/src/api_prototype/kernel_generator.dart' as fe;
+import 'package:front_end/src/fasta/kernel/utils.dart' as fe;
+import 'package:kernel/ast.dart' as fe;
+import 'package:kernel/target/targets.dart' as fe;
+import 'package:vm/kernel_front_end.dart' as vm;
+import 'package:vm/target/vm.dart' as vm;
+
+Future<void> runBinaryProtocol(String addressStr) async {
+  final parsedAddress = _ParsedAddress.parse(addressStr);
+  final socket = await io.Socket.connect(
+    parsedAddress.host,
+    parsedAddress.port,
+  );
+
+  _Client(
+    RequestChannel(socket),
+    () {
+      socket.destroy();
+    },
+  );
+}
+
+class _Client {
+  final RequestChannel _channel;
+  final void Function() _stopHandler;
+  final Map<Uri, Uint8List> _dills = {};
+
+  _Client(this._channel, this._stopHandler) {
+    _channel.add('dill.put', _dillPut);
+    _channel.add('dill.remove', _dillRemove);
+    _channel.add('exit', _exit);
+    _channel.add('kernelForModule', _kernelForModule);
+    _channel.add('kernelForProgram', _kernelForProgram);
+    _channel.add('stop', _stop);
+  }
+
+  Future<void> _dillPut(Object? argumentObject) async {
+    final arguments = argumentObject.argumentAsMap;
+    final uriStr = arguments.required<String>('uri');
+    final bytes = arguments.required<Uint8List>('bytes');
+
+    final uri = Uri.parse(uriStr);
+    _dills[uri] = bytes;
+  }
+
+  Future<void> _dillRemove(Object? argumentObject) async {
+    final arguments = argumentObject.argumentAsMap;
+    final uriStr = arguments.required<String>('uri');
+
+    final uri = Uri.parse(uriStr);
+    _dills.remove(uri);
+  }
+
+  Future<void> _exit(Object? argument) async {
+    io.exit(0);
+  }
+
+  fe.CompilerOptions _getCompilerOptions(Map<Object?, Object?> arguments) {
+    final sdkSummaryUriStr = arguments.required<String>('sdkSummary');
+
+    final compilerOptions = fe.CompilerOptions()
+      ..environmentDefines = {}
+      ..fileSystem = _FileSystem(_channel, _dills)
+      ..sdkSummary = Uri.parse(sdkSummaryUriStr)
+      ..target = vm.VmTarget(fe.TargetFlags(enableNullSafety: true));
+
+    final additionalDills = arguments['additionalDills'].asListOf<String>();
+    if (additionalDills != null) {
+      compilerOptions.additionalDills.addAll(
+        additionalDills.map(Uri.parse),
+      );
+    }
+
+    return compilerOptions;
+  }
+
+  Future<Object?> _kernelForModule(Object? argumentObject) async {
+    final arguments = argumentObject.argumentAsMap;
+    final packagesFileUriStr = arguments.required<String>('packagesFileUri');
+
+    final compilerOptions = _getCompilerOptions(arguments)
+      ..packagesFileUri = Uri.parse(packagesFileUriStr);
+
+    final uriStrList = arguments['uris'].asListOf<String>();
+    if (uriStrList == null) {
+      throw ArgumentError('Missing field: uris');
+    }
+
+    final compilationResults = await fe.kernelForModule(
+      uriStrList.map(Uri.parse).toList(),
+      compilerOptions,
+    );
+
+    return _serializeComponentWithoutPlatform(
+      compilationResults.component!,
+    );
+  }
+
+  Future<Object?> _kernelForProgram(Object? argumentObject) async {
+    final arguments = argumentObject.argumentAsMap;
+
+    final compilerOptions = _getCompilerOptions(arguments);
+
+    final packagesFileUriStr = arguments.optional<String>('packagesFileUri');
+    if (packagesFileUriStr != null) {
+      compilerOptions.packagesFileUri = Uri.parse(packagesFileUriStr);
+    }
+
+    final uriStr = arguments.required<String>('uri');
+
+    final compilationResults = await vm.compileToKernel(
+      Uri.parse(uriStr),
+      compilerOptions,
+      environmentDefines: {},
+    );
+
+    return _serializeComponentWithoutPlatform(
+      compilationResults.component!,
+    );
+  }
+
+  Future<void> _stop(Object? argument) async {
+    _stopHandler();
+  }
+
+  static Uint8List _serializeComponentWithoutPlatform(fe.Component component) {
+    return fe.serializeComponent(
+      component,
+      filter: (library) {
+        return !library.importUri.isScheme('dart');
+      },
+      includeSources: false,
+    );
+  }
+}
+
+class _FileSystem implements fe.FileSystem {
+  final RequestChannel _channel;
+  final Map<Uri, Uint8List> _dills;
+
+  _FileSystem(this._channel, this._dills);
+
+  @override
+  fe.FileSystemEntity entityForUri(Uri uri) {
+    return _FileSystemEntity(this, uri);
+  }
+}
+
+class _FileSystemEntity implements fe.FileSystemEntity {
+  final _FileSystem _fileSystem;
+
+  @override
+  final Uri uri;
+
+  _FileSystemEntity(this._fileSystem, this.uri);
+
+  RequestChannel get _channel => _fileSystem._channel;
+
+  String get _uriStr => uri.toString();
+
+  @override
+  Future<bool> exists() async {
+    if (_fileSystem._dills.containsKey(uri)) {
+      return true;
+    }
+    return _channel.sendRequest<bool>('file.exists', _uriStr);
+  }
+
+  @override
+  Future<bool> existsAsyncIfPossible() => exists();
+
+  @override
+  Future<List<int>> readAsBytes() async {
+    final storedBytes = _fileSystem._dills[uri];
+    if (storedBytes != null) {
+      return storedBytes;
+    }
+
+    return _channel.sendRequest<Uint8List>('file.readAsBytes', _uriStr);
+  }
+
+  @override
+  Future<List<int>> readAsBytesAsyncIfPossible() => readAsBytes();
+
+  @override
+  Future<String> readAsString() async {
+    return _channel.sendRequest<String>('file.readAsString', _uriStr);
+  }
+}
+
+class _ParsedAddress {
+  final String host;
+  final int port;
+
+  factory _ParsedAddress.parse(String str) {
+    final colonOffset = str.lastIndexOf(':');
+    if (colonOffset == -1) {
+      throw FormatException("Expected ':' in: $str");
+    }
+
+    return _ParsedAddress._(
+      str.substring(0, colonOffset),
+      int.parse(str.substring(colonOffset + 1)),
+    );
+  }
+
+  _ParsedAddress._(this.host, this.port);
+}
+
+extension on Object? {
+  Map<Object?, Object?> get argumentAsMap {
+    final self = this;
+    if (self is Map<Object?, Object?>) {
+      return self;
+    }
+    throw ArgumentError('The argument must be a map.');
+  }
+}
+
+extension on Map<Object?, Object?> {
+  T? optional<T extends Object>(String name) {
+    final value = this[name];
+    if (value == null) {
+      return null;
+    }
+    if (value is T) {
+      return value;
+    }
+    throw ArgumentError('Must be null or $T: $name');
+  }
+
+  T required<T>(String name) {
+    final value = this[name];
+    if (value is T) {
+      return value;
+    }
+    throw ArgumentError('Must be $T: $name');
+  }
+}
+
+extension on Object? {
+  List<T>? asListOf<T>() {
+    final self = this;
+    if (self is List<Object?>) {
+      final result = <T>[];
+      for (final element in self) {
+        if (element is T) {
+          result.add(element);
+        } else {
+          return null;
+        }
+      }
+      return result;
+    }
+    return null;
+  }
+}
diff --git a/pkg/frontend_server/test/frontend_server_test.dart b/pkg/frontend_server/test/frontend_server_test.dart
index d34b067..46457d0 100644
--- a/pkg/frontend_server/test/frontend_server_test.dart
+++ b/pkg/frontend_server/test/frontend_server_test.dart
@@ -3,10 +3,12 @@
 import 'dart:convert';
 import 'dart:io';
 import 'dart:isolate';
+import 'dart:typed_data';
 
+import 'package:_fe_analyzer_shared/src/macros/compiler/request_channel.dart';
 import 'package:front_end/src/api_unstable/vm.dart';
-import 'package:kernel/binary/ast_to_binary.dart';
 import 'package:kernel/ast.dart' show Component;
+import 'package:kernel/binary/ast_to_binary.dart';
 import 'package:kernel/kernel.dart' show loadComponentFromBinary;
 import 'package:kernel/verifier.dart' show verifyComponent;
 import 'package:mockito/mockito.dart';
@@ -16,15 +18,6 @@
 
 import '../lib/frontend_server.dart';
 
-class _MockedCompiler extends Mock implements CompilerInterface {}
-
-class _MockedIncrementalCompiler extends Mock implements IncrementalCompiler {}
-
-class _MockedBinaryPrinterFactory extends Mock implements BinaryPrinterFactory {
-}
-
-class _MockedBinaryPrinter extends Mock implements BinaryPrinter {}
-
 void main() async {
   group('basic', () {
     final CompilerInterface compiler = _MockedCompiler();
@@ -1798,6 +1791,214 @@
       });
     });
 
+    group('binary protocol', () {
+      var fileContentMap = <Uri, String>{};
+
+      setUp(() {
+        fileContentMap = {};
+      });
+
+      void addFileCallbacks(RequestChannel requestChannel) {
+        requestChannel.add('file.exists', (uriStr) async {
+          final uri = Uri.parse(uriStr as String);
+          return fileContentMap.containsKey(uri);
+        });
+        requestChannel.add('file.readAsBytes', (uriStr) async {
+          final uri = Uri.parse(uriStr as String);
+          final content = fileContentMap[uri];
+          return content != null ? utf8.encode(content) : Uint8List(0);
+        });
+        requestChannel.add('file.readAsStringSync', (uriStr) async {
+          final uri = Uri.parse(uriStr as String);
+          return fileContentMap[uri] ?? '';
+        });
+      }
+
+      Future<ServerSocket> loopbackServerSocket() async {
+        try {
+          return await ServerSocket.bind(InternetAddress.loopbackIPv6, 0);
+        } on SocketException catch (_) {
+          return await ServerSocket.bind(InternetAddress.loopbackIPv4, 0);
+        }
+      }
+
+      Uri registerKernelBlob(Uint8List bytes) {
+        bytes = Uint8List.fromList(bytes);
+        return (Isolate.current as dynamic).createUriForKernelBlob(bytes);
+      }
+
+      Future<void> runWithServer(
+        Future<void> Function(RequestChannel) f,
+      ) async {
+        final testFinished = Completer<void>();
+        final serverSocket = await loopbackServerSocket();
+
+        serverSocket.listen((socket) async {
+          final requestChannel = RequestChannel(socket);
+
+          try {
+            await f(requestChannel);
+          } finally {
+            requestChannel.sendRequest('stop', {});
+            socket.destroy();
+            serverSocket.close();
+            testFinished.complete();
+          }
+        });
+
+        final host = serverSocket.address.address;
+        final addressStr = '$host:${serverSocket.port}';
+        expect(await starter(['--binary-protocol-address=${addressStr}']), 0);
+
+        await testFinished.future;
+      }
+
+      group('dill.put', () {
+        test('not Map argument', () async {
+          await runWithServer((requestChannel) async {
+            try {
+              await requestChannel.sendRequest<Uint8List>('dill.put', 42);
+              fail('Expected RemoteException');
+            } on RemoteException {}
+          });
+        });
+
+        test('no field: uri', () async {
+          await runWithServer((requestChannel) async {
+            try {
+              await requestChannel.sendRequest<Uint8List>('dill.put', {});
+              fail('Expected RemoteException');
+            } on RemoteException {}
+          });
+        });
+
+        test('no field: bytes', () async {
+          await runWithServer((requestChannel) async {
+            try {
+              await requestChannel.sendRequest<Uint8List>('dill.put', {
+                'uri': 'vm:dill',
+              });
+              fail('Expected RemoteException');
+            } on RemoteException {}
+          });
+        });
+
+        test('OK', () async {
+          await runWithServer((requestChannel) async {
+            await requestChannel.sendRequest<Uint8List>('dill.put', {
+              'uri': 'vm:dill',
+              'bytes': Uint8List(256),
+            });
+          });
+        });
+      });
+
+      group('dill.remove', () {
+        test('not Map argument', () async {
+          await runWithServer((requestChannel) async {
+            try {
+              await requestChannel.sendRequest<Uint8List>('dill.remove', 42);
+              fail('Expected RemoteException');
+            } on RemoteException {}
+          });
+        });
+
+        test('no field: uri', () async {
+          await runWithServer((requestChannel) async {
+            try {
+              await requestChannel.sendRequest<Uint8List>('dill.remove', {});
+              fail('Expected RemoteException');
+            } on RemoteException {}
+          });
+        });
+
+        test('OK', () async {
+          await runWithServer((requestChannel) async {
+            await requestChannel.sendRequest<Uint8List>('dill.remove', {
+              'uri': 'vm:dill',
+            });
+          });
+        });
+      });
+
+      group('kernelForProgram', () {
+        test('not Map argument', () async {
+          await runWithServer((requestChannel) async {
+            try {
+              await requestChannel.sendRequest<Uint8List>(
+                'kernelForProgram',
+                42,
+              );
+              fail('Expected RemoteException');
+            } on RemoteException {}
+          });
+        });
+
+        test('no field: sdkSummary', () async {
+          await runWithServer((requestChannel) async {
+            try {
+              await requestChannel.sendRequest<Uint8List>(
+                'kernelForProgram',
+                {},
+              );
+              fail('Expected RemoteException');
+            } on RemoteException {}
+          });
+        });
+
+        test('no field: uri', () async {
+          await runWithServer((requestChannel) async {
+            try {
+              await requestChannel.sendRequest<Uint8List>('kernelForProgram', {
+                'sdkSummary': 'dill:vm',
+              });
+              fail('Expected RemoteException');
+            } on RemoteException {}
+          });
+        });
+
+        test('compiles', () async {
+          await runWithServer((requestChannel) async {
+            addFileCallbacks(requestChannel);
+
+            await requestChannel.sendRequest<void>('dill.put', {
+              'uri': 'dill:vm',
+              'bytes': File(
+                path.join(
+                  path.dirname(path.dirname(Platform.resolvedExecutable)),
+                  'lib',
+                  '_internal',
+                  'vm_platform_strong.dill',
+                ),
+              ).readAsBytesSync(),
+            });
+
+            fileContentMap[Uri.parse('file:///home/test/lib/test.dart')] = r'''
+import 'dart:isolate';
+void main(List<String> arguments, SendPort sendPort) {
+  sendPort.send(42);
+}
+''';
+
+            final kernelBytes = await requestChannel.sendRequest<Uint8List>(
+              'kernelForProgram',
+              {
+                'sdkSummary': 'dill:vm',
+                'uri': 'file:///home/test/lib/test.dart',
+              },
+            );
+
+            expect(kernelBytes, hasLength(greaterThan(200)));
+            final kernelUri = registerKernelBlob(kernelBytes);
+
+            final receivePort = ReceivePort();
+            await Isolate.spawnUri(kernelUri, [], receivePort.sendPort);
+            expect(await receivePort.first, 42);
+          });
+        });
+      });
+    });
+
     test('compile to JavaScript', () async {
       var file = File('${tempDir.path}/foo.dart')..createSync();
       file.writeAsStringSync("main() {\n}\n");
@@ -2897,30 +3098,15 @@
   }
 }
 
-class Result {
-  String status;
-  List<String> sources;
-
-  Result(this.status, this.sources);
-
-  void expectNoErrors({String filename}) {
-    var result = CompilationResult.parse(status);
-    expect(result.errorsCount, equals(0));
-    if (filename != null) {
-      expect(result.filename, equals(filename));
-    }
-  }
-}
-
 class OutputParser {
-  OutputParser(this._receivedResults);
   bool expectSources = true;
-
   StreamController<Result> _receivedResults;
-  List<String> _receivedSources;
 
+  List<String> _receivedSources;
   String _boundaryKey;
+
   bool _readingSources;
+  OutputParser(this._receivedResults);
 
   void listener(String s) {
     if (_boundaryKey == null) {
@@ -2959,3 +3145,27 @@
     }
   }
 }
+
+class Result {
+  String status;
+  List<String> sources;
+
+  Result(this.status, this.sources);
+
+  void expectNoErrors({String filename}) {
+    var result = CompilationResult.parse(status);
+    expect(result.errorsCount, equals(0));
+    if (filename != null) {
+      expect(result.filename, equals(filename));
+    }
+  }
+}
+
+class _MockedBinaryPrinter extends Mock implements BinaryPrinter {}
+
+class _MockedBinaryPrinterFactory extends Mock implements BinaryPrinterFactory {
+}
+
+class _MockedCompiler extends Mock implements CompilerInterface {}
+
+class _MockedIncrementalCompiler extends Mock implements IncrementalCompiler {}
diff --git a/runtime/vm/compiler/backend/il_arm.cc b/runtime/vm/compiler/backend/il_arm.cc
index fde11b60..3bdaac0 100644
--- a/runtime/vm/compiler/backend/il_arm.cc
+++ b/runtime/vm/compiler/backend/il_arm.cc
@@ -3691,7 +3691,7 @@
                                      instruction()->deopt_id(),
                                      instruction()->source());
     } else {
-      __ CallRuntime(kStackOverflowRuntimeEntry, kNumSlowPathArgs);
+      __ CallRuntime(kInterruptOrStackOverflowRuntimeEntry, kNumSlowPathArgs);
       compiler->EmitCallsiteMetadata(
           instruction()->source(), instruction()->deopt_id(),
           UntaggedPcDescriptors::kOther, instruction()->locs(), env);
diff --git a/runtime/vm/compiler/backend/il_arm64.cc b/runtime/vm/compiler/backend/il_arm64.cc
index 7506894..88f0e9a 100644
--- a/runtime/vm/compiler/backend/il_arm64.cc
+++ b/runtime/vm/compiler/backend/il_arm64.cc
@@ -3247,7 +3247,7 @@
                                      instruction()->deopt_id(),
                                      instruction()->source());
     } else {
-      __ CallRuntime(kStackOverflowRuntimeEntry, kNumSlowPathArgs);
+      __ CallRuntime(kInterruptOrStackOverflowRuntimeEntry, kNumSlowPathArgs);
       compiler->EmitCallsiteMetadata(
           instruction()->source(), instruction()->deopt_id(),
           UntaggedPcDescriptors::kOther, instruction()->locs(), env);
diff --git a/runtime/vm/compiler/backend/il_ia32.cc b/runtime/vm/compiler/backend/il_ia32.cc
index 4869e16..06243b2 100644
--- a/runtime/vm/compiler/backend/il_ia32.cc
+++ b/runtime/vm/compiler/backend/il_ia32.cc
@@ -2898,7 +2898,7 @@
         instruction(), /*num_slow_path_args=*/0);
     compiler->pending_deoptimization_env_ = env;
 
-    __ CallRuntime(kStackOverflowRuntimeEntry, kNumSlowPathArgs);
+    __ CallRuntime(kInterruptOrStackOverflowRuntimeEntry, kNumSlowPathArgs);
     compiler->EmitCallsiteMetadata(
         instruction()->source(), instruction()->deopt_id(),
         UntaggedPcDescriptors::kOther, instruction()->locs(), env);
diff --git a/runtime/vm/compiler/backend/il_riscv.cc b/runtime/vm/compiler/backend/il_riscv.cc
index a029815..b24fdb4 100644
--- a/runtime/vm/compiler/backend/il_riscv.cc
+++ b/runtime/vm/compiler/backend/il_riscv.cc
@@ -3494,7 +3494,7 @@
                                      instruction()->deopt_id(),
                                      instruction()->source());
     } else {
-      __ CallRuntime(kStackOverflowRuntimeEntry, kNumSlowPathArgs);
+      __ CallRuntime(kInterruptOrStackOverflowRuntimeEntry, kNumSlowPathArgs);
       compiler->EmitCallsiteMetadata(
           instruction()->source(), instruction()->deopt_id(),
           UntaggedPcDescriptors::kOther, instruction()->locs(), env);
diff --git a/runtime/vm/compiler/backend/il_x64.cc b/runtime/vm/compiler/backend/il_x64.cc
index 023874d..ae2531a 100644
--- a/runtime/vm/compiler/backend/il_x64.cc
+++ b/runtime/vm/compiler/backend/il_x64.cc
@@ -3325,7 +3325,7 @@
                                      instruction()->deopt_id(),
                                      instruction()->source());
     } else {
-      __ CallRuntime(kStackOverflowRuntimeEntry, kNumSlowPathArgs);
+      __ CallRuntime(kInterruptOrStackOverflowRuntimeEntry, kNumSlowPathArgs);
       compiler->EmitCallsiteMetadata(
           instruction()->source(), instruction()->deopt_id(),
           UntaggedPcDescriptors::kOther, instruction()->locs(), env);
diff --git a/runtime/vm/compiler/stub_code_compiler.cc b/runtime/vm/compiler/stub_code_compiler.cc
index 199ae30..33ef038 100644
--- a/runtime/vm/compiler/stub_code_compiler.cc
+++ b/runtime/vm/compiler/stub_code_compiler.cc
@@ -1037,7 +1037,8 @@
 void StubCodeCompiler::GenerateStackOverflowSharedWithoutFPURegsStub(
     Assembler* assembler) {
   GenerateSharedStub(
-      assembler, /*save_fpu_registers=*/false, &kStackOverflowRuntimeEntry,
+      assembler, /*save_fpu_registers=*/false,
+      &kInterruptOrStackOverflowRuntimeEntry,
       target::Thread::stack_overflow_shared_without_fpu_regs_stub_offset(),
       /*allow_return=*/true);
 }
@@ -1045,7 +1046,8 @@
 void StubCodeCompiler::GenerateStackOverflowSharedWithFPURegsStub(
     Assembler* assembler) {
   GenerateSharedStub(
-      assembler, /*save_fpu_registers=*/true, &kStackOverflowRuntimeEntry,
+      assembler, /*save_fpu_registers=*/true,
+      &kInterruptOrStackOverflowRuntimeEntry,
       target::Thread::stack_overflow_shared_with_fpu_regs_stub_offset(),
       /*allow_return=*/true);
 }
diff --git a/runtime/vm/runtime_entry.cc b/runtime/vm/runtime_entry.cc
index 2fb6faf..a249423 100644
--- a/runtime/vm/runtime_entry.cc
+++ b/runtime/vm/runtime_entry.cc
@@ -2853,7 +2853,7 @@
 }
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 
-DEFINE_RUNTIME_ENTRY(StackOverflow, 0) {
+DEFINE_RUNTIME_ENTRY(InterruptOrStackOverflow, 0) {
 #if defined(USING_SIMULATOR)
   uword stack_pos = Simulator::Current()->get_sp();
   // If simulator was never called it may return 0 as a value of SPREG.
diff --git a/runtime/vm/runtime_entry_list.h b/runtime/vm/runtime_entry_list.h
index 5731d55..857784b 100644
--- a/runtime/vm/runtime_entry_list.h
+++ b/runtime/vm/runtime_entry_list.h
@@ -51,7 +51,7 @@
   V(ArgumentErrorUnboxedInt64)                                                 \
   V(IntegerDivisionByZeroException)                                            \
   V(ReThrow)                                                                   \
-  V(StackOverflow)                                                             \
+  V(InterruptOrStackOverflow)                                                  \
   V(Throw)                                                                     \
   V(DeoptimizeMaterialize)                                                     \
   V(RewindPostDeopt)                                                           \
diff --git a/tools/VERSION b/tools/VERSION
index d5f67ab..c45d641 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 18
 PATCH 0
-PRERELEASE 19
+PRERELEASE 20
 PRERELEASE_PATCH 0
\ No newline at end of file