diff --git a/pkg/dart2wasm/lib/compile.dart b/pkg/dart2wasm/lib/compile.dart
index b4a2cfb53bf..c835c7949ca 100644
--- a/pkg/dart2wasm/lib/compile.dart
+++ b/pkg/dart2wasm/lib/compile.dart
@@ -37,6 +37,7 @@ import 'package:wasm_builder/wasm_builder.dart' show Serializer;
 import 'compiler_options.dart' as compiler;
 import 'constant_evaluator.dart';
 import 'deferred_loading.dart';
+import 'dry_run.dart';
 import 'dynamic_module_kernel_metadata.dart';
 import 'dynamic_modules.dart';
 import 'js/runtime_generator.dart' as js;
@@ -49,6 +50,12 @@ import 'translator.dart';
 
 sealed class CompilationResult {}
 
+abstract class CompilationDryRunResult extends CompilationResult {}
+
+class CompilationDryRunError extends CompilationDryRunResult {}
+
+class CompilationDryRunSuccess extends CompilationDryRunResult {}
+
 class CompilationSuccess extends CompilationResult {
   final Map<String, ({Uint8List moduleBytes, String? sourceMap})> wasmModules;
   final String jsRuntime;
@@ -79,7 +86,9 @@ class CFECrashError extends CompilationError {
 /// (We print them as soon as they are reported by CFE. i.e. we stream errors
 /// instead of accumulating/batching all of them and reporting at the end.)
 class CFECompileTimeErrors extends CompilationError {
-  CFECompileTimeErrors();
+  final Component? component;
+
+  CFECompileTimeErrors(this.component);
 }
 
 const List<String> _librariesToIndex = [
@@ -199,7 +208,18 @@ Future<CompilationResult> compileToModule(
   } catch (e, s) {
     return CFECrashError(e, s);
   }
-  if (hadCompileTimeError) return CFECompileTimeErrors();
+  if (options.dryRun) {
+    final component = compilerResult?.component;
+    if (component == null) {
+      return CompilationDryRunError();
+    }
+    final summarizer = DryRunSummarizer(component);
+    final hasErrors = summarizer.summarize();
+    return hasErrors ? CompilationDryRunError() : CompilationDryRunSuccess();
+  }
+  if (hadCompileTimeError) {
+    return CFECompileTimeErrors(compilerResult?.component);
+  }
   assert(compilerResult != null);
 
   Component component = compilerResult!.component!;
diff --git a/pkg/dart2wasm/lib/compiler_options.dart b/pkg/dart2wasm/lib/compiler_options.dart
index 6d120e7ab7b..47cfd42f27e 100644
--- a/pkg/dart2wasm/lib/compiler_options.dart
+++ b/pkg/dart2wasm/lib/compiler_options.dart
@@ -29,6 +29,7 @@ class WasmCompilerOptions {
   String? dumpKernelAfterCfe;
   String? dumpKernelBeforeTfa;
   String? dumpKernelAfterTfa;
+  bool dryRun = false;
 
   factory WasmCompilerOptions.defaultOptions() =>
       WasmCompilerOptions(mainUri: Uri(), outputFile: '');
diff --git a/pkg/dart2wasm/lib/dart2wasm.dart b/pkg/dart2wasm/lib/dart2wasm.dart
index 55a56bbeaff..dab5155258c 100644
--- a/pkg/dart2wasm/lib/dart2wasm.dart
+++ b/pkg/dart2wasm/lib/dart2wasm.dart
@@ -26,6 +26,7 @@ final List<Option> options = [
       defaultsTo: _d.translatorOptions.inlining),
   Flag("minify", (o, value) => o.translatorOptions.minify = value,
       defaultsTo: _d.translatorOptions.minify),
+  Flag("dry-run", (o, value) => o.dryRun = value, defaultsTo: _d.dryRun),
   Flag("polymorphic-specialization",
       (o, value) => o.translatorOptions.polymorphicSpecialization = value,
       defaultsTo: _d.translatorOptions.polymorphicSpecialization),
diff --git a/pkg/dart2wasm/lib/dry_run.dart b/pkg/dart2wasm/lib/dry_run.dart
new file mode 100644
index 00000000000..efeaef5054e
--- /dev/null
+++ b/pkg/dart2wasm/lib/dry_run.dart
@@ -0,0 +1,227 @@
+// Copyright (c) 2025, 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 'package:_js_interop_checks/js_interop_checks.dart';
+import 'package:collection/collection.dart';
+import 'package:front_end/src/api_prototype/codes.dart'
+    show Message, LocatedMessage;
+import 'package:kernel/ast.dart';
+import 'package:kernel/class_hierarchy.dart';
+import 'package:kernel/core_types.dart';
+import 'package:kernel/target/targets.dart' show DiagnosticReporter;
+import 'package:kernel/type_environment.dart';
+
+enum _DryRunErrorCode {
+  noDartHtml(0),
+  noDartJs(1),
+  interopChecksError(2),
+  isTestValueError(3),
+  isTestTypeError(4),
+  isTestGenericTypeError(5),
+  ;
+
+  const _DryRunErrorCode(this.code);
+
+  final int code;
+}
+
+class _DryRunError {
+  final _DryRunErrorCode code;
+  final String problemMessage;
+  final Uri? errorSourceUri;
+  final Location? errorLocation;
+
+  _DryRunError(this.code, this.problemMessage,
+      {this.errorSourceUri, this.errorLocation});
+
+  static String _locationToString(Uri? sourceUri, Location? location) {
+    if (sourceUri == null && location == null) return 'unknown location';
+    final uri = sourceUri ?? location?.file;
+    final lineCol =
+        location != null ? ' ${location.line}:${location.column}' : '';
+    return '$uri$lineCol';
+  }
+
+  @override
+  String toString() => '${_locationToString(errorSourceUri, errorLocation)} '
+      '- $problemMessage (${code.code})';
+}
+
+/// Runs several passes over the provided kernel to find any code in the
+/// sources that could block a migration to WASM from JS.
+///
+/// At the end of execution, it emits a summary to stdout that looks like:
+/// ```
+/// Found incompatibilities with WebAssembly.
+///
+/// package:dryrun/test.dart 5:15 - Cannot test a JS value against String (3)
+/// package:dryrun/test.dart 6:7 - JS interop class 'B' cannot extend Dart class 'A'. (2)
+/// ````
+class DryRunSummarizer {
+  final Component component;
+  late final CoreTypes coreTypes;
+  late final ClassHierarchy classHierarchy;
+
+  DryRunSummarizer(this.component) {
+    coreTypes = CoreTypes(component);
+    classHierarchy = ClassHierarchy(component, coreTypes);
+  }
+
+  static const Map<String, _DryRunErrorCode> _disallowedDartUris = {
+    'dart:html': _DryRunErrorCode.noDartHtml,
+    'dart:js': _DryRunErrorCode.noDartJs,
+    // 'dart:ffi' is handled by interop checks.
+  };
+
+  List<_DryRunError> _analyzeImports() {
+    final errors = <_DryRunError>[];
+
+    for (final library in component.libraries) {
+      if (library.importUri.scheme == 'dart') continue;
+
+      for (final dep in library.dependencies) {
+        final depLib = dep.importedLibraryReference.asLibrary;
+        final code = _disallowedDartUris[depLib.importUri.toString()];
+        if (code != null) {
+          errors.add(_DryRunError(code, '${depLib.importUri} unsupported',
+              errorSourceUri: library.importUri, errorLocation: dep.location));
+        }
+      }
+    }
+
+    return errors;
+  }
+
+  List<_DryRunError> _interopChecks() {
+    final collector = _CollectingDiagnosticReporter(component);
+    final reporter = JsInteropDiagnosticReporter(collector);
+    // These checks will already have been done by the CFE but the message
+    // format the CFE provides for those errors makes it hard to identify them
+    // as interop-specific errors. Instead we rerun and collect any errors here.
+    component.accept(JsInteropChecks(coreTypes, classHierarchy, reporter,
+        JsInteropChecks.getNativeClasses(component),
+        isDart2Wasm: true));
+    return collector.errors;
+  }
+
+  List<_DryRunError> _analyzeComponent() {
+    final analyzer = _AnalysisVisitor(coreTypes, classHierarchy);
+    component.accept(analyzer);
+    return analyzer.errors;
+  }
+
+  bool summarize() {
+    final errors = [
+      ..._analyzeImports(),
+      ..._interopChecks(),
+      ..._analyzeComponent(),
+    ];
+
+    if (errors.isNotEmpty) {
+      print('Found incompatibilities with WebAssembly.\n');
+      print(errors.join('\n'));
+      return true;
+    }
+    return false;
+  }
+}
+
+class _CollectingDiagnosticReporter
+    extends DiagnosticReporter<Message, LocatedMessage> {
+  final Component component;
+  final List<_DryRunError> errors = <_DryRunError>[];
+
+  _CollectingDiagnosticReporter(this.component);
+
+  @override
+  void report(Message message, int charOffset, int length, Uri? fileUri,
+      {List<LocatedMessage>? context}) {
+    final libraryUri = fileUri != null
+        ? component.libraries
+            .firstWhereOrNull((e) => e.fileUri == fileUri)
+            ?.importUri
+        : null;
+    final location =
+        fileUri != null ? component.getLocation(fileUri, charOffset) : null;
+    errors.add(_DryRunError(
+        _DryRunErrorCode.interopChecksError, message.problemMessage,
+        errorSourceUri: libraryUri ?? fileUri, errorLocation: location));
+  }
+}
+
+class _AnalysisVisitor extends RecursiveVisitor {
+  Library? _enclosingLibrary;
+  late StaticTypeContext _context;
+  final TypeEnvironment _typeEnvironment;
+  final DartType _jsAnyType;
+  final List<_DryRunError> errors = [];
+
+  _AnalysisVisitor(CoreTypes coreTypes, ClassHierarchy hierarchy)
+      : _typeEnvironment = TypeEnvironment(coreTypes, hierarchy),
+        _jsAnyType = ExtensionType(
+            coreTypes.index.getExtensionType('dart:js_interop', 'JSAny'),
+            Nullability.nullable);
+
+  @override
+  void visitLibrary(Library node) {
+    if (node.importUri.scheme == 'dart') return;
+    _enclosingLibrary = node;
+    _context = StaticTypeContext.forAnnotations(node, _typeEnvironment);
+    super.visitLibrary(node);
+    _enclosingLibrary = null;
+  }
+
+  @override
+  void visitProcedure(Procedure node) {
+    _context = StaticTypeContext(node, _typeEnvironment);
+    super.visitProcedure(node);
+  }
+
+  @override
+  void visitIsExpression(IsExpression node) {
+    final operandStaticType = node.operand.getStaticType(_context);
+    if (_typeEnvironment.isSubtypeOf(operandStaticType, _jsAnyType)) {
+      errors.add(_DryRunError(
+          _DryRunErrorCode.isTestValueError,
+          'Should not perform an `is` test on a JS value. Use `isA` with a JS '
+          'value type instead.',
+          errorSourceUri: _enclosingLibrary?.importUri,
+          errorLocation: node.location));
+    }
+    if (_typeEnvironment.isSubtypeOf(node.type, _jsAnyType)) {
+      errors.add(_DryRunError(
+          _DryRunErrorCode.isTestTypeError,
+          'Should not perform an `is` test against a JS value type. '
+          'Use `isA` instead.',
+          errorSourceUri: _enclosingLibrary?.importUri,
+          errorLocation: node.location));
+    } else if (_hasJsTypeArguments(node.type)) {
+      errors.add(_DryRunError(
+          _DryRunErrorCode.isTestGenericTypeError,
+          'Should not perform an `is` test against a generic DartType with JS '
+          'type arguments.',
+          errorSourceUri: _enclosingLibrary?.importUri,
+          errorLocation: node.location));
+    }
+    super.visitIsExpression(node);
+  }
+
+  bool _hasJsTypeArguments(DartType type) {
+    // Check InterfaceType and ExtensionType
+    if (type is TypeDeclarationType) {
+      final arguments = type.typeArguments;
+      if (arguments.any((e) => _typeEnvironment.isSubtypeOf(e, _jsAnyType))) {
+        return true;
+      }
+      return arguments.any(_hasJsTypeArguments);
+    } else if (type is RecordType) {
+      final fields = type.positional.followedBy(type.named.map((t) => t.type));
+      if (fields.any((e) => _typeEnvironment.isSubtypeOf(e, _jsAnyType))) {
+        return true;
+      }
+      return fields.any(_hasJsTypeArguments);
+    }
+    return false;
+  }
+}
diff --git a/pkg/dart2wasm/lib/generate_wasm.dart b/pkg/dart2wasm/lib/generate_wasm.dart
index 2595e3f84f6..94366addfe8 100644
--- a/pkg/dart2wasm/lib/generate_wasm.dart
+++ b/pkg/dart2wasm/lib/generate_wasm.dart
@@ -78,9 +78,17 @@ Future<int> generateWasm(WasmCompilerOptions options,
 
   CompilationResult result =
       await compileToModule(options, relativeSourceMapUrlMapper, (message) {
-    printDiagnosticMessage(message, errorPrinter);
+    if (!options.dryRun) printDiagnosticMessage(message, errorPrinter);
   });
 
+  if (result is CompilationDryRunResult) {
+    assert(options.dryRun);
+    if (result is CompilationDryRunError) {
+      return 254;
+    }
+    return 0;
+  }
+
   // If the compilation to wasm failed we use appropriate exit codes recognized
   // by our test infrastructure. We use the same exit codes as the VM does. See:
   //    runtime/bin/error_exit.h:kDartFrontendErrorExitCode
diff --git a/pkg/dart2wasm/pubspec.yaml b/pkg/dart2wasm/pubspec.yaml
index c065abd938f..12a0c34d8cc 100644
--- a/pkg/dart2wasm/pubspec.yaml
+++ b/pkg/dart2wasm/pubspec.yaml
@@ -21,4 +21,6 @@ dependencies:
 
 # Use 'any' constraints here; we get our versions from the DEPS file.
 dev_dependencies:
+  expect: any
+  js: any
   lints: any
diff --git a/pkg/dart2wasm/test/dry_run/dry_run_test.dart b/pkg/dart2wasm/test/dry_run/dry_run_test.dart
new file mode 100644
index 00000000000..50b320c4113
--- /dev/null
+++ b/pkg/dart2wasm/test/dry_run/dry_run_test.dart
@@ -0,0 +1,299 @@
+// Copyright (c) 2025, 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:convert';
+import 'dart:io';
+
+import 'package:args/args.dart';
+import 'package:collection/collection.dart';
+import 'package:expect/expect.dart';
+
+final dartAotExecutable = Uri.parse(Platform.resolvedExecutable)
+    .resolve('dartaotruntime')
+    .toFilePath();
+final dart2wasmSnapshot = Uri.parse(Platform.resolvedExecutable)
+    .resolve('snapshots/dart2wasm_product.snapshot')
+    .toFilePath();
+final platformDill = Uri.parse(Platform.resolvedExecutable)
+    .resolve('../lib/_internal/dart2wasm_platform.dill')
+    .toFilePath();
+
+class TestExpectation {
+  final int expectedErrorCode;
+  final String? expectedErrorSubstring;
+  final int lineNumber;
+
+  TestExpectation(
+      this.expectedErrorCode, this.expectedErrorSubstring, this.lineNumber);
+
+  factory TestExpectation.fromLine(String line, int lineNumber) {
+    final errorText = line.replaceAll('// DRY_RUN:', '').trim().split(',');
+    final expectedErrorCode = int.parse(errorText[0].trim());
+    final expectedErrorSubstring =
+        errorText.length > 1 ? errorText.sublist(1).join(',').trim() : null;
+    return TestExpectation(
+        expectedErrorCode, expectedErrorSubstring, lineNumber);
+  }
+}
+
+class TestFinding {
+  final int errorCode;
+  final String problemMessage;
+  final Uri? errorSourceUri;
+  final int? errorLine;
+  final int? errorColumn;
+
+  TestFinding(this.errorCode, this.problemMessage, this.errorSourceUri,
+      this.errorLine, this.errorColumn);
+
+  factory TestFinding.fromLine(String line) {
+    final parts = line.split(' - ');
+    final locationInfo = parts[0].split(' ');
+    final uri = locationInfo[0].trim();
+    final lineCol = locationInfo[1].split(':');
+    final lineNumber = int.parse(lineCol[0].trim());
+    final columnNumber = int.parse(lineCol[1].trim());
+    final problemMessage = parts[1];
+    final errorCodeStart = problemMessage.lastIndexOf('(');
+    final errorCodeEnd = problemMessage.lastIndexOf(')');
+    final errorCode =
+        int.parse(problemMessage.substring(errorCodeStart + 1, errorCodeEnd));
+    return TestFinding(
+        errorCode,
+        problemMessage.substring(0, errorCodeStart).trim(),
+        Uri.parse(uri),
+        lineNumber,
+        columnNumber);
+  }
+}
+
+enum Status { pass, fail, crash }
+
+class TestResults {
+  final String name;
+  final Status status;
+  final Duration time;
+  final String details;
+
+  TestResults(this.name, this.status, this.time, this.details);
+
+  String toRecordJson(String configuration) {
+    final outcome = switch (status) {
+      Status.pass => 'Pass',
+      Status.crash => 'Crash',
+      Status.fail => 'RuntimeError',
+    };
+    return jsonEncode({
+      'name': 'dry_run/$name',
+      'configuration': configuration,
+      'suite': 'dry_run',
+      'test_name': name,
+      'time_ms': time.inMilliseconds,
+      'expected': 'Pass',
+      'result': outcome,
+      'matches': status == Status.pass,
+    });
+  }
+
+  String toLogJson(String configuration) {
+    final outcome = switch (status) {
+      Status.pass => 'Pass',
+      Status.crash => 'Crash',
+      Status.fail => 'RuntimeError',
+    };
+    return jsonEncode({
+      'name': 'dry_run/$name',
+      'configuration': configuration,
+      'result': outcome,
+      'log': details,
+    });
+  }
+}
+
+class TestCase {
+  final Uri path;
+  final List<TestExpectation> expectations;
+
+  TestCase(this.path, this.expectations);
+
+  String get name => path.pathSegments.last.replaceAll('.dart', '');
+}
+
+Future<TestResults> runTest(TestCase testCase) async {
+  print('Executing test: ${testCase.name}');
+  final timer = Stopwatch();
+  timer.start();
+  ProcessResult result;
+  try {
+    result = await Process.run(dartAotExecutable, [
+      dart2wasmSnapshot,
+      testCase.path.toFilePath(),
+      '--platform=$platformDill',
+      '--dry-run',
+      'out.wasm',
+    ]);
+  } catch (e, s) {
+    timer.stop();
+    return TestResults(testCase.name, Status.crash, timer.elapsed, '$e\n$s');
+  }
+  timer.stop();
+  try {
+    final exitCode = result.exitCode;
+    Expect.equals(testCase.expectations.isEmpty ? 0 : 254, exitCode);
+    final findings = _parseTestFindings(result.stdout);
+    _checkFindings(findings, testCase.expectations);
+  } catch (e, s) {
+    return TestResults(testCase.name, Status.fail, timer.elapsed, '$e\n$s');
+  }
+  return TestResults(testCase.name, Status.pass, timer.elapsed, '');
+}
+
+/// Generates a report of the test results in the JSON format
+/// that is expected by our testing infrastructure.
+int reportResults(
+  List<TestResults> results, {
+  String? configuration,
+  String? logDir,
+}) {
+  bool fail = false;
+  print('Test results:');
+  for (var result in results) {
+    print('  ${result.name}: ${result.status}');
+    if (result.status != Status.pass) fail = true;
+  }
+  if (fail) print('Error: some tests failed');
+
+  if (logDir == null) {
+    print('Error: no output directory provided, logs won\'t be emitted.');
+    return 1;
+  }
+  if (configuration == null) {
+    print('Error: no configuration name provided, logs won\'t be emitted.');
+    return 1;
+  }
+
+  // Ensure the directory URI ends with a path separator.
+  var dirUri = Directory(logDir).uri;
+  File.fromUri(dirUri.resolve('results.json')).writeAsStringSync(
+    results.map((r) => '${r.toRecordJson(configuration)}\n').join(),
+    flush: true,
+  );
+  File.fromUri(dirUri.resolve('logs.json')).writeAsStringSync(
+    results
+        .where((r) => r.status != Status.pass)
+        .map((r) => '${r.toLogJson(configuration)}\n')
+        .join(),
+    flush: true,
+  );
+
+  print('Success: log files emitted under $dirUri');
+  return 0;
+}
+
+Future<List<TestCase>> _loadTestCases() async {
+  final testCaseDir = Directory.fromUri(Platform.script.resolve('testcases'));
+  final testCases = <TestCase>[];
+  for (final file in testCaseDir.listSync(recursive: true)) {
+    if (file is File && file.path.endsWith('.dart')) {
+      testCases.add(await _parseTestCase(file.uri));
+    }
+  }
+  return testCases;
+}
+
+Future<TestCase> _parseTestCase(Uri path) async {
+  final fileContents = await File.fromUri(path).readAsString();
+  final lines = fileContents.split('\n');
+  final expectations = <TestExpectation>[];
+  int lineIndex = 0;
+  for (final line in lines) {
+    if (line.contains('// DRY_RUN:')) {
+      final nextNonCommentLine =
+          lines.indexWhere((l) => !l.trim().startsWith('//'), lineIndex + 1) +
+              1;
+      expectations.add(TestExpectation.fromLine(line, nextNonCommentLine));
+    }
+    lineIndex++;
+  }
+  return TestCase(path, expectations);
+}
+
+List<TestFinding> _parseTestFindings(String result) {
+  final lines = result.split('\n');
+  final findings = <TestFinding>[];
+  // Skip header and newline.
+  for (final line in lines.skip(2)) {
+    if (line.isEmpty) continue;
+    findings.add(TestFinding.fromLine(line));
+  }
+  return findings;
+}
+
+void _checkFindings(
+    List<TestFinding> findings, List<TestExpectation> expectations) {
+  Expect.equals(
+      findings.length,
+      expectations.length,
+      'Incorrect number of findings. '
+      'Expected: ${expectations.length}, Actual: ${findings.length}');
+  for (final expectation in expectations) {
+    final lineNumber = expectation.lineNumber;
+    final lineFindings =
+        findings.where((finding) => finding.errorLine == lineNumber);
+
+    final matchingFinding = lineFindings.firstWhereOrNull(
+        (finding) => finding.errorCode == expectation.expectedErrorCode);
+
+    Expect.isNotNull(
+      matchingFinding,
+      'No finding found for expectation on line $lineNumber',
+    );
+    Expect.equals(
+        expectation.expectedErrorCode,
+        matchingFinding!.errorCode,
+        'Unexpected error code for expectation on line $lineNumber. '
+        'Expected: ${expectation.expectedErrorCode}, Actual: ${matchingFinding.errorCode}');
+    if (expectation.expectedErrorSubstring != null) {
+      Expect.contains(
+          expectation.expectedErrorSubstring!, matchingFinding.problemMessage);
+    }
+  }
+}
+
+Future<int> main(List<String> args) async {
+  final parser = ArgParser()
+    ..addOption(
+      'configuration',
+      help: 'Configuration to use for reporting test results',
+      abbr: 'n',
+    )
+    ..addOption(
+      'output-directory',
+      help: 'Location to emit the json-l result and log files',
+    )
+    ..addFlag(
+      'verbose',
+      help: 'Show more information',
+      negatable: false,
+      abbr: 'v',
+    );
+  final parsedArgs = parser.parse(args);
+  final configuration = parsedArgs.option('configuration');
+  final outputDirectory = parsedArgs.option('output-directory');
+  final verbose = parsedArgs.flag('verbose');
+
+  final testCases = await _loadTestCases();
+
+  final results = <TestResults>[];
+  for (final testCase in testCases) {
+    final testResult = await runTest(testCase);
+    results.add(testResult);
+    if (verbose && testResult.status != Status.pass) {
+      print(testResult.details);
+    }
+  }
+
+  return reportResults(results,
+      configuration: configuration, logDir: outputDirectory);
+}
diff --git a/pkg/dart2wasm/test/dry_run/testcases/analysis_options.yaml b/pkg/dart2wasm/test/dry_run/testcases/analysis_options.yaml
new file mode 100644
index 00000000000..623fe2da461
--- /dev/null
+++ b/pkg/dart2wasm/test/dry_run/testcases/analysis_options.yaml
@@ -0,0 +1,8 @@
+include: package:lints/recommended.yaml
+
+analyzer:
+  errors:
+    depend_on_referenced_packages: ignore
+    deprecated_member_use: ignore
+    invalid_runtime_check_with_js_interop_types: ignore
+    unused_import: ignore
diff --git a/pkg/dart2wasm/test/dry_run/testcases/import_ffi.dart b/pkg/dart2wasm/test/dry_run/testcases/import_ffi.dart
new file mode 100644
index 00000000000..2324f0e25a4
--- /dev/null
+++ b/pkg/dart2wasm/test/dry_run/testcases/import_ffi.dart
@@ -0,0 +1,8 @@
+// Copyright (c) 2025, 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.
+
+// DRY_RUN: 2, dart:ffi
+import 'dart:ffi';
+
+void main() {}
diff --git a/pkg/dart2wasm/test/dry_run/testcases/import_html.dart b/pkg/dart2wasm/test/dry_run/testcases/import_html.dart
new file mode 100644
index 00000000000..c8d80855afb
--- /dev/null
+++ b/pkg/dart2wasm/test/dry_run/testcases/import_html.dart
@@ -0,0 +1,8 @@
+// Copyright (c) 2025, 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.
+
+// DRY_RUN: 0, dart:html
+import 'dart:html';
+
+void main() {}
diff --git a/pkg/dart2wasm/test/dry_run/testcases/import_js.dart b/pkg/dart2wasm/test/dry_run/testcases/import_js.dart
new file mode 100644
index 00000000000..0ca0481cd31
--- /dev/null
+++ b/pkg/dart2wasm/test/dry_run/testcases/import_js.dart
@@ -0,0 +1,8 @@
+// Copyright (c) 2025, 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.
+
+// DRY_RUN: 1, dart:js
+import 'dart:js';
+
+void main() {}
diff --git a/pkg/dart2wasm/test/dry_run/testcases/import_package_js.dart b/pkg/dart2wasm/test/dry_run/testcases/import_package_js.dart
new file mode 100644
index 00000000000..16e6b113e24
--- /dev/null
+++ b/pkg/dart2wasm/test/dry_run/testcases/import_package_js.dart
@@ -0,0 +1,8 @@
+// Copyright (c) 2025, 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.
+
+// DRY_RUN: 2, package:js
+import 'package:js/js.dart';
+
+void main() {}
diff --git a/pkg/dart2wasm/test/dry_run/testcases/malformed_is.dart b/pkg/dart2wasm/test/dry_run/testcases/malformed_is.dart
new file mode 100644
index 00000000000..cc48c32f8e7
--- /dev/null
+++ b/pkg/dart2wasm/test/dry_run/testcases/malformed_is.dart
@@ -0,0 +1,34 @@
+// Copyright (c) 2025, 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:js_interop';
+
+void main() {
+  JSAny? jsValue;
+  // DRY_RUN: 3,  Should not perform an `is` test on a JS value
+  if (jsValue is String) {
+    print(jsValue);
+    // DRY_RUN: 3,  Should not perform an `is` test on a JS value
+    // DRY_RUN: 4,  Should not perform an `is` test against a JS value type
+  } else if (jsValue is JSArray) {
+    print(jsValue);
+  }
+
+  Object? dartValue;
+  if (dartValue is String) {
+    print(dartValue);
+    // DRY_RUN: 4,  Should not perform an `is` test against a JS value type
+  } else if (dartValue is JSArray) {
+    print(dartValue);
+    // DRY_RUN: 5,  Should not perform an `is` test against a generic DartType with JS type arguments
+  } else if (dartValue is List<JSString>) {
+    print(dartValue);
+    // DRY_RUN: 5,  Should not perform an `is` test against a generic DartType with JS type arguments
+  } else if (dartValue is (JSString,)) {
+    print(dartValue);
+    // DRY_RUN: 5,  Should not perform an `is` test against a generic DartType with JS type arguments
+  } else if (dartValue is List<(JSString,)>) {
+    print(dartValue);
+  }
+}
diff --git a/pkg/dart2wasm/test/dry_run/testcases/valid_interop_import.dart b/pkg/dart2wasm/test/dry_run/testcases/valid_interop_import.dart
new file mode 100644
index 00000000000..e836e48450d
--- /dev/null
+++ b/pkg/dart2wasm/test/dry_run/testcases/valid_interop_import.dart
@@ -0,0 +1,14 @@
+// Copyright (c) 2025, 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:js_interop';
+
+void main() {
+  JSAny? jsValue;
+  if (jsValue.isA<JSString>()) {
+    print(jsValue);
+  } else if (jsValue.isA<JSArray>()) {
+    print(jsValue);
+  }
+}
diff --git a/pkg/dartdev/lib/src/commands/compile.dart b/pkg/dartdev/lib/src/commands/compile.dart
index 2ae83766328..02aa1d0804a 100644
--- a/pkg/dartdev/lib/src/commands/compile.dart
+++ b/pkg/dartdev/lib/src/commands/compile.dart
@@ -1031,6 +1031,11 @@ class CompileWasmCommand extends CompileSubcommandCommand {
 
     final bool strip = args.flag('strip-wasm');
 
+    // When running in dry run mode there will not be any file emitted.
+    final isDryRun = extraCompilerOptions.any((e) => e.contains('dry-run'));
+
+    if (isDryRun) return 0;
+
     if (runWasmOpt) {
       final unoptFile = '$outputFileBasename.unopt.wasm';
       File(outputFile).renameSync(unoptFile);
diff --git a/tools/bots/test_matrix.json b/tools/bots/test_matrix.json
index ef8e8d6ae80..c0d0c6eff67 100644
--- a/tools/bots/test_matrix.json
+++ b/tools/bots/test_matrix.json
@@ -2663,6 +2663,15 @@
           ],
           "shards": 8,
           "fileset": "dart2wasm_hostasserts"
+        },
+        {
+          "name": "dart2wasm unit tests",
+          "script":  "out/ReleaseX64/dart-sdk/bin/dart",
+          "testRunner": true,
+          "arguments": [
+            "pkg/dart2wasm/test/dry_run/dry_run_test.dart",
+            "-ndart2wasm-asserts-linux-chrome"
+          ]
         }
       ]
     },