basalt-win32 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vince Vella
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/cli/runWindows.js

@@ -0,0 +1,35 @@
+/**
+ * `react-native run-windows`.
+ *
+ * Four strings and a path. Everything a desktop run actually does is in
+ * basalt-core's cli/desktop.js, shared with `run-linux` and
+ * `run-macos`, because none of it is about a toolkit -- see the note at the top
+ * of that file.
+ *
+ * The command name is react-native-windows', deliberately: an app that already
+ * knows `react-native run-windows` should not have to learn a second spelling
+ * to try this one. Same argument as the `windows` platform name.
+ *
+ * @format
+ */
+
+// @ts-check
+'use strict';
+
+const path = require('path');
+
+const {shared, sharedPackageDir} = require('./shared');
+
+const {makeRunCommand} = shared('cli/desktop');
+
+module.exports = makeRunCommand({
+  platform: 'windows',
+  label: 'Windows',
+  command: 'run-windows',
+  binary: 'basalt_win32.exe',
+  nativeDir: path.resolve(__dirname, '..', 'native'),
+  coreDir: path.join(sharedPackageDir(), 'native'),
+  toolchain:
+    'the Visual Studio Build Tools with clang-cl, a Git Bash to run bootstrap.sh in, ' +
+    'and a vcpkg with glog, fmt, double-conversion, boost, gflags, openssl and curl',
+});

package/cli/shared.js

@@ -0,0 +1,75 @@
+/**
+ * Reaching basalt-core, the shared half, from this package.
+ *
+ * The one file in a platform package's CLI that cannot itself be shared,
+ * because it is what finds the thing everything else is shared through. Two
+ * layouts matter and only one of them resolves by name.
+ *
+ * Installed into an app, basalt-core is a sibling in node_modules and
+ * `require('basalt-core/...')` finds it. In a checkout of this
+ * repository the two packages are sibling directories with nothing installed
+ * between them -- deliberately, since this repo has no node_modules of its own
+ * -- and the same require fails. So: by name first, because that is the layout
+ * an app is in, and beside us second, because that is the layout it is
+ * developed in.
+ *
+ * Both reach the *built* package. basalt-core is TypeScript: by name
+ * resolves through its `exports` map, which points into `dist/`, and the
+ * sibling path has to say so itself. A checkout that has not run
+ * scripts/build_ts.sh has nothing here to find, which is what the error says.
+ *
+ * @format
+ */
+
+// @ts-check
+'use strict';
+
+const path = require('path');
+
+const SIBLING = path.resolve(__dirname, '..', '..', 'basalt-core');
+
+/**
+ * Where basalt-core is on disk. Same two layouts, same order.
+ * @returns {string}
+ */
+function sharedPackageDir() {
+  try {
+    return path.dirname(require.resolve('basalt-core/package.json'));
+  } catch (error) {
+    if (/** @type {NodeJS.ErrnoException} */ (error).code !== 'MODULE_NOT_FOUND') {
+      throw error;
+    }
+    return SIBLING;
+  }
+}
+
+/**
+ * One of basalt-core's modules, by subpath.
+ * @param {string} subpath
+ * @returns {any}
+ */
+function shared(subpath) {
+  const name = `basalt-core/${subpath}`;
+  try {
+    return require(name);
+  } catch (error) {
+    if (/** @type {NodeJS.ErrnoException} */ (error).code !== 'MODULE_NOT_FOUND') {
+      // The module was found and threw on its way up. Passing it through keeps
+      // a real error in that file from being reported as a missing package.
+      throw error;
+    }
+    try {
+      return require(path.join(SIBLING, 'dist', subpath));
+    } catch (siblingError) {
+      if (/** @type {NodeJS.ErrnoException} */ (siblingError).code === 'MODULE_NOT_FOUND') {
+        throw new Error(
+          `could not load ${name}. In a checkout, basalt-core has to be ` +
+            'built first: run scripts/build_ts.sh.',
+        );
+      }
+      throw siblingError;
+    }
+  }
+}
+
+module.exports = {shared, sharedPackageDir};

package/native/CMakeLists.txt

@@ -0,0 +1,429 @@
+# basalt-win32 — the Windows view layer, over Win32 and Direct2D.
+#
+# A view layer, a mounting manager and a host. Everything behind them is in
+# basalt-core, which this adds as a subdirectory.
+#
+# `win32/` rather than `windows/`: the toolkit is what differs, and the name
+# would be wrong the moment WinUI or something after it mattered. The npm
+# package is `-win32` for the same reason `-appkit` is not `-macos`, and neither
+# name is the JavaScript platform's -- that one is `windows`, matching
+# react-native-windows, and lives in the shared package.
+
+cmake_minimum_required(VERSION 3.13)
+project(basalt_win32 CXX)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+# Executables at the top of the build tree whether this is configured directly
+# or added by a wrapper, so `build/basalt_win32` means the same thing either
+# way. Every script and document here names that path.
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
+# ...including under the multi-config generators, which are the default on
+# Windows: Visual Studio and Ninja Multi-Config both append Debug/ or Release/
+# to the directory above unless told otherwise, and a document that says
+# `build/basalt_win32_tests` would be wrong on the platform it was written for.
+foreach(config ${CMAKE_CONFIGURATION_TYPES})
+  string(TOUPPER ${config} config_upper)
+  set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_${config_upper} ${CMAKE_BINARY_DIR})
+endforeach()
+
+# ---------------------------------------------------------------------------
+# Finding basalt-core, the shared half.
+#
+# The default works in both layouts this can be built from: a checkout of this
+# repository, where the packages are siblings under packages/, and an app's
+# node_modules, where npm hoists them side by side.
+#
+# Guarded on the target rather than on the variable: a build that configures
+# more than one platform package would otherwise add the same directory twice,
+# which CMake refuses.
+# ---------------------------------------------------------------------------
+if(NOT TARGET basalt_core)
+  if(NOT DEFINED BASALT_CORE_DIR)
+    set(BASALT_CORE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../basalt-core/native)
+  endif()
+  get_filename_component(BASALT_CORE_DIR "${BASALT_CORE_DIR}" ABSOLUTE)
+  if(NOT EXISTS ${BASALT_CORE_DIR}/CMakeLists.txt)
+    message(FATAL_ERROR
+      "basalt-core not found at ${BASALT_CORE_DIR}.\n"
+      "Pass -DBASALT_CORE_DIR=<path to basalt-core/native>.")
+  endif()
+  # Capability packages first, and only here, because they contribute include
+  # directories to basalt_core and CMake resolves those when the target is
+  # created rather than afterwards.
+  #
+  # This used to live only in the repository's root CMakeLists, which is the
+  # entry point for a checkout and is not the entry point for an app: the CLI
+  # configures -S <host package>/native, so the loop never ran and
+  # core/portability_probe.cpp failed on a Notifications.h that nothing had
+  # put on the path. A checkout could not see it, because there the root added
+  # the packages first and the header was always there.
+  #
+  # Guarded on the property rather than the variable for the same reason the
+  # block around it is guarded on the target: a build configuring two host
+  # packages must not add the same directory twice.
+  get_property(basalt_packages_added GLOBAL PROPERTY BASALT_PACKAGES_ADDED)
+  if(NOT basalt_packages_added)
+    set_property(GLOBAL PROPERTY BASALT_PACKAGES_ADDED TRUE)
+    foreach(package ${BASALT_PACKAGES})
+      if(EXISTS ${package}/native/CMakeLists.txt)
+        get_filename_component(basalt_package_name ${package} NAME)
+        message(STATUS "basalt: capability package ${basalt_package_name}")
+        add_subdirectory(${package}/native basalt-package-${basalt_package_name})
+      endif()
+    endforeach()
+  endif()
+
+  add_subdirectory(${BASALT_CORE_DIR} basalt_core)
+endif()
+
+# What capability packages contributed for this host; see
+# packages/basalt-notifications for what a package sets.
+#
+# Read *after* the block above, because that block is where the packages are
+# added. It used to be read at the top of this file, which worked for a
+# checkout -- the root CMakeLists adds the packages before it adds this one --
+# and silently contributed nothing for an app, where this file is the entry
+# point. The symptom was a link error naming every notification seam.
+get_property(BASALT_PACKAGE_WIN32_SOURCES GLOBAL PROPERTY BASALT_PACKAGE_WIN32_SOURCES)
+# And what those sources need linked. A package contributing an implementation
+# that reaches for a library had no way to say so; see the same property in the
+# AppKit package for what went missing.
+get_property(BASALT_PACKAGE_WIN32_LINK_LIBRARIES GLOBAL PROPERTY BASALT_PACKAGE_WIN32_LINK_LIBRARIES)
+# And a package's own unit tests, which run in this host's suite. A capability
+# with a platform half has nowhere else to be tested: it is compiled into the
+# host binary, so the host's suite is the only binary that has it.
+get_property(BASALT_PACKAGE_TESTS GLOBAL PROPERTY BASALT_PACKAGE_TESTS)
+
+if(NOT WIN32)
+  # Not an error. A checkout builds every package it finds, and on anything but
+  # Windows this one has nothing it could compile.
+  message(STATUS "basalt-win32 skipped: not Windows")
+  return()
+endif()
+
+# ---------------------------------------------------------------------------
+# What this project's own sources are held to.
+#
+# The GTK and AppKit halves say `-Wall -Wextra`, which MSVC does not speak.
+# /W4 is the nearest equivalent and /permissive- is the part that matters more:
+# without it MSVC accepts things no other compiler in this project would, and
+# the first anyone would hear of it is the Linux build failing on code that
+# compiled here. Set on targets rather than globally, so React Native's own
+# sources -- which set their own flags and are not warning-clean under /W4 --
+# never inherit them.
+#
+# Note that clang-cl reports as MSVC here, which is intended: it takes the same
+# flags, and `docs/DECISIONS.md` prefers clang where there is a choice.
+# ---------------------------------------------------------------------------
+if(MSVC)
+  set(BASALT_WIN32_WARNINGS /W4 /permissive-)
+else()
+  set(BASALT_WIN32_WARNINGS -Wall -Wextra)
+endif()
+
+# UNICODE, because every Win32 entry point in this project takes wide strings
+# and the ANSI variants silently lose anything outside the active code page --
+# which for React Native, where a string is UTF-8 from JavaScript, is most of
+# the world. NOMINMAX and WIN32_LEAN_AND_MEAN because windows.h otherwise
+# defines `min` and `max` as macros and breaks <algorithm> at a distance.
+#
+# _CRT_SECURE_NO_WARNINGS is not laziness about a real hazard: what it silences
+# here is C4996 on `std::getenv`, which the other two platforms call in the same
+# place for the same reason and which has no portable replacement. Anything that
+# genuinely wants the checked CRT can ask for it on its own.
+add_compile_definitions(UNICODE _UNICODE NOMINMAX WIN32_LEAN_AND_MEAN _CRT_SECURE_NO_WARNINGS)
+
+# ---------------------------------------------------------------------------
+# basalt_win32_view — the Win32 view layer.
+#
+# No React Native dependency, so it builds and is tested on its own, on a
+# Windows box with nothing installed but a compiler and the SDK. Direct2D, WIC
+# and USER32 all ship with the operating system; there is nothing to fetch.
+# ---------------------------------------------------------------------------
+add_library(basalt_win32_view STATIC
+  win32/RnWin32View.cpp
+  # The paragraph object. DirectWrite only, no React Native, which is what keeps
+  # this target buildable and testable with nothing else installed.
+  win32/RnWin32TextLayout.cpp
+  # <Image> pixels: the WIC decode and the four resize modes. The fetch that
+  # feeds it is core/ImageBytes.cpp in the shared half, because a URI means the
+  # same thing on every desktop.
+  win32/RnWin32Image.cpp
+  # UI Automation. Windows inverts what the other two do -- a provider answers
+  # questions rather than a widget carrying properties; see the header.
+  win32/RnWin32Accessible.cpp
+  # Offscreen rendering, to a PNG or to pixels a test can read. The second is
+  # why this is in the view target rather than beside the demo: it is what the
+  # rendering assertions in tests/test_win32_paint.cpp are built on.
+  win32/Win32Snapshot.cpp
+  # The cursors Windows has no stock art for -- six CSS keywords drawn here as
+  # DIBs. Header-only until they were drawn; see Win32Cursors.h.
+  win32/Win32Cursors.cpp
+  # Where a hidden title bar's pieces are -- the caption buttons and the drag
+  # regions. Pure geometry over the view tree, so it is tested here with no
+  # window and no React Native.
+  win32/Win32TitleBarLayout.cpp)
+target_compile_options(basalt_win32_view PRIVATE ${BASALT_WIN32_WARNINGS})
+target_include_directories(basalt_win32_view PUBLIC win32)
+# The header-only part of core, and only that: FocusRing.h, Backface.h,
+# ImageAnimation.h and ShadowShape.h so far. None of them has React Native in
+# it, so taking them does not make this target depend on the half that does --
+# and the alternative is a focus ring that is a different blue on each desktop,
+# three toolkits each with their own idea of which way a rotated card is facing,
+# a GIF paced differently on each, and a hand-rolled copy of CSS's shadow-corner
+# cubic per platform.
+#
+# Header-only is the constraint, not a preference: this library links no core,
+# so anything it takes from there has to be `inline`.
+target_include_directories(basalt_win32_view PUBLIC
+    ${CMAKE_CURRENT_SOURCE_DIR}/../../basalt-core/native/core)
+# dxguid is for the effect CLSIDs, and it is the kind of thing that only a
+# linker tells you: `CLSID_D2D1Shadow` and its siblings are `DEFINE_GUID`
+# declarations in d2d1effects.h, so the symbols live in that library rather
+# than in d2d1. Without it a text shadow compiles and fails to link.
+target_link_libraries(basalt_win32_view PUBLIC
+  d2d1 dwrite windowscodecs uiautomationcore ole32 oleaut32 user32 shcore dxguid)
+
+add_executable(demo_layout_win32 win32/demo_layout_win32.cpp)
+target_compile_options(demo_layout_win32 PRIVATE ${BASALT_WIN32_WARNINGS})
+target_link_libraries(demo_layout_win32 PRIVATE basalt_win32_view)
+
+# The runner comes from the shared half, which knows about no toolkit: the test
+# infrastructure is shared even though the views are not. Unlike the GTK suite
+# this one brings no separate entry point -- there is nothing to initialise
+# before a view exists -- so `main` sits at the bottom of test_win32_view.cpp,
+# as it does on the AppKit side.
+set(BASALT_WIN32_TEST_SOURCES
+  ${BASALT_TEST_HARNESS}
+  tests/test_win32_view.cpp
+  # What actually reached the pixels. Needs no display and no window, which is
+  # why this platform can assert it and the other two cannot; see the file.
+  tests/test_win32_paint.cpp
+  # Picking. In the view layer rather than beside a touch dispatcher, so that
+  # testing it needs no React Native -- the same arrangement AppKit settled on.
+  tests/test_win32_hittest.cpp
+  # DirectWrite measurement, against RnWin32TextLayout alone.
+  tests/test_win32_text.cpp
+  # The resize modes, against a real bitmap and real pixels.
+  tests/test_win32_image.cpp
+  # The UIA mapping. The React Native role name is what the cross-platform diff
+  # compares; this is where the platform half is checked.
+  tests/test_win32_accessibility.cpp
+  # A hidden title bar's geometry: the caption buttons and the drag regions.
+  tests/test_win32_titlebar.cpp)
+
+# ---------------------------------------------------------------------------
+# basalt_win32_mounting — the Windows half of the Fabric mounting manager.
+#
+# The mutation walk is not here: it is in the shared half, in
+# core/MountingWalk.h. What is here is what is genuinely Windows about mounting,
+# plus the four seams a platform owes the core.
+#
+# Skipped when the build was not pointed at a React Native, so the view layer
+# above still builds and tests on a Windows box with nothing but a compiler.
+# ---------------------------------------------------------------------------
+if(TARGET basalt_core)
+  add_library(basalt_win32_mounting STATIC
+    win32/Win32MountingManager.cpp
+    # Mouse messages -> React Native touches. In the library rather than in the
+    # host so that tests can drive it, which is the only way the touch state
+    # machine is provable without a cursor.
+    win32/Win32Focus.cpp
+    win32/Win32KeyEvents.cpp
+    # Why Windows cannot show a notification; see the file.
+    ${BASALT_PACKAGE_WIN32_SOURCES}
+    # The AppUserModelID and the Start Menu shortcut behind it, which is what
+    # makes a notification say which application it came from.
+    win32/Win32Packaging.cpp
+    win32/Win32TouchDispatcher.cpp
+    # <ScrollView>: the offset, the unthrottled state write-back, the wheel and
+    # the commands. Routing the wheel is this platform's alone -- there is no
+    # responder chain and no per-widget controller to attach one to.
+    win32/Win32ScrollView.cpp
+    # <TextInput>: a real EDIT control, which is a child window rather than a
+    # painted view -- so it is also the only component whose peer the host has
+    # to position, forward messages to, and answer colour questions for.
+    win32/Win32TextInput.cpp
+    # <Image> pixels: the fetch and the decode, both off the UI thread. The
+    # fetch itself is core/ImageBytes.cpp in the shared half.
+    win32/Win32ImageLoader.cpp
+    # Which components this platform claims. See core/ComponentRegistry.h, and
+    # note this and Win32MountingManager::hasComponent must agree.
+    win32/ComponentRegistryWin32.cpp
+    # AttributedString -> RnWin32TextLayout. Shared by measurement and painting,
+    # so they agree, which is the whole reason it is one file.
+    win32/DirectWriteLayout.cpp
+    # Replaces React Native's stub TextLayoutManager; see the shared half's
+    # cmake/ReactNativeCore.cmake for why the stub has to leave the build.
+    win32/DirectWriteLayoutManager.cpp
+    # Windows' implementation of core/FontRegistry.h -- the seam phase 17 named.
+    win32/FontRegistryDirectWrite.cpp
+    # ...and of core/ColorScheme.h.
+    win32/ColorSchemeWin32.cpp
+    # ...and of core/PlatformServices.h, which is also where postToUiThread
+    # lives -- the marshalling the mounting manager depends on.
+    win32/PlatformServicesWin32.cpp
+    # The window's title bar: DWM's colours and dark mode, and the caption the
+    # host draws when an app hides the system's. And BasaltWindow, the module
+    # JavaScript reaches it through.
+    # Accepting a file or text dragged onto the window; see
+    # core/DragAndDrop.h for the model the three hosts share.
+    win32/Win32DropTarget.cpp
+    win32/Win32TitleBar.cpp
+    # A window's size, position and full-screen state; see core/WindowControl.h.
+    win32/Win32WindowControl.cpp
+    # The application menu; see core/MenuModel.h for why the three differ.
+    win32/Win32MenuBar.cpp
+    win32/Win32WindowModule.cpp)
+  target_compile_options(basalt_win32_mounting PRIVATE ${BASALT_WIN32_WARNINGS})
+  target_include_directories(basalt_win32_mounting PUBLIC win32)
+  target_link_libraries(basalt_win32_mounting PUBLIC basalt_win32_view basalt_core)
+
+  # @shopify/react-native-skia, when the build was pointed at an app that has
+  # it. See ../../basalt-core/native/cmake/Skia.cmake.
+  #
+  # Here rather than on basalt_core, for the reason the AppKit package gives:
+  # a platform context is a host's dependency. The Windows one reaches
+  # DirectWrite and the Win32 DPI call, and core/portability_probe.cpp links
+  # the core with no toolkit on purpose.
+  if(TARGET skia_core)
+    target_link_libraries(basalt_win32_mounting PUBLIC skia_core)
+    target_sources(basalt_win32_mounting PUBLIC $<TARGET_OBJECTS:skia_core>)
+    target_compile_definitions(basalt_win32_mounting PUBLIC BASALT_HAS_SKIA=1)
+    # This host's half: the TurboModule the package asks for by name, the
+    # platform context it hands to Skia, and the peer behind a `<Canvas>`.
+    # See win32/Win32SkiaModule.h and win32/Win32SkiaPeer.h.
+    target_sources(basalt_win32_mounting PRIVATE
+      win32/Win32SkiaModule.cpp
+      win32/Win32SkiaContext.cpp
+      # AppKitSkiaPeer.mm's opposite number. Where that one hands the package a
+      # Metal layer, this renders into memory and lets the Direct2D walk draw
+      # the result -- this host has no layer tree to hang a canvas in.
+      win32/Win32SkiaPeer.cpp
+      # The unicode factory the package asks for by name on anything that is
+      # not Apple, answered with the backend that is actually linked here.
+      win32/Win32SkiaUnicode.cpp)
+  endif()
+  # shell32 for ShellExecute; comctl32 for SetWindowSubclass, which is how a
+  # <TextInput>'s EDIT peer is subclassed without breaking anything else that
+  # subclasses it later.
+  # shell32 for Shell_NotifyIcon and SHGetKnownFolderPath, ole32 for the
+  # IShellLink that writes the Start Menu shortcut, propsys for the property
+  # store that puts the AppUserModelID on it.
+  target_link_libraries(basalt_win32_mounting PUBLIC shell32 comctl32 ole32 propsys)
+  # dwmapi for the title bar's colours and dark mode.
+  target_link_libraries(basalt_win32_mounting PUBLIC dwmapi)
+
+  # -------------------------------------------------------------------------
+  # basalt_win32 — a ReactHost, Hermes, and one surface in an HWND.
+  # -------------------------------------------------------------------------
+  add_executable(basalt_win32
+    win32/main_win32.cpp
+    # The event beat. Not an observer on Windows: there is no "about to wait"
+    # hook, so the message loop itself is here. See the header.
+    win32/Win32RunLoopObserver.cpp
+    win32/Win32AnimationChoreographer.cpp)
+  target_compile_options(basalt_win32 PRIVATE ${BASALT_WIN32_WARNINGS})
+  target_link_libraries(basalt_win32 PRIVATE basalt_win32_mounting)
+  if(BASALT_PACKAGE_WIN32_LINK_LIBRARIES)
+    target_link_libraries(basalt_win32 PRIVATE ${BASALT_PACKAGE_WIN32_LINK_LIBRARIES})
+  endif()
+
+  # Real mutations into real views, with no JavaScript anywhere. The checkpoint
+  # between "the mounting manager compiles" and "React Native runs": a mistake
+  # in the Create/Insert/Update/Remove/Delete handling shows up in a picture
+  # rather than in review.
+  add_executable(mount_harness_win32 win32/mount_harness_win32.cpp)
+  target_compile_options(mount_harness_win32 PRIVATE ${BASALT_WIN32_WARNINGS})
+  target_link_libraries(mount_harness_win32 PRIVATE basalt_win32_mounting)
+
+  list(APPEND BASALT_WIN32_TEST_SOURCES
+    ${BASALT_CORE_TESTS}
+    # Key events, and the mapping under test. Here rather than in the
+    # unconditional set above, which is where they were: core/KeyEvents.h
+    # speaks in facebook::react::Tag and includes ReactPrimitives.h for it, so
+    # anything touching it needs a React Native to have been found. The view
+    # layer deliberately has not found one -- that is what lets it build on a
+    # Windows box with nothing but a compiler -- and the release workflow's
+    # MSBuild job is exactly that build, so it failed there and nowhere else.
+    # This host is still the only one that can check the table, and the
+    # Windows CI shards, which do have React Native, still do.
+    tests/test_win32_key_events.cpp
+    # Selecting text with a pointer, here for the same reason and found the
+    # same way: it drives a Win32TouchDispatcher and asserts against
+    # core/TextSelection.h, both of which speak React Native, and it sat in
+    # the unconditional set above from the day it was written. The MSBuild job
+    # is the only build without a React Native, so it failed there and nowhere
+    # else -- the second time this file has learnt that, which is why the
+    # rule is now in the comment above rather than in a commit message.
+    tests/test_win32_selection.cpp
+    win32/Win32KeyEvents.cpp
+    # A package's own tests; see the AppKit package for why they sit with core's.
+    ${BASALT_PACKAGE_TESTS}
+    # Deliberately the same nine questions tests/test_mounting.cpp asks of GTK
+    # and tests/test_appkit_mounting.mm asks of AppKit, in the same order with
+    # the same tags. Most of what they test is whether the sharing still holds.
+    tests/test_win32_mounting.cpp
+    # The image loader: the cache, the failure paths, and the two lifetimes.
+    # In the RN-dependent set because the fetch is core/ImageBytes.cpp.
+    tests/test_win32_imageloader.cpp
+    # Animated GIFs: the frames WIC decodes and the pacing core shares. Here
+    # for the same reason as the loader's own tests -- the fixtures are `data:`
+    # URIs, read by core/ImageBytes.cpp -- even though most of the file is the
+    # view layer's.
+    tests/test_win32_animated_image.cpp
+    # The touch state machine and the gesture handover, asking what
+    # tests/test_appkit_input.mm asks of AppKit.
+    tests/test_win32_input.cpp
+    # <ScrollView>: the clamp, the throttle, the state write-back, the wheel's
+    # innermost-first routing and the commands.
+    tests/test_win32_focus.cpp
+    tests/test_win32_scrollview.cpp
+    # <TextInput>. The only tests here that make a window, because a text
+    # field's peer is one -- see the file.
+    tests/test_win32_textinput.cpp
+    # The clipboard, and what happens when another program has it open.
+    tests/test_win32_clipboard.cpp
+    # The caption actions with no window attached. Here rather than beside
+    # test_win32_titlebar.cpp because Win32TitleBar is in basalt_win32_mounting,
+    # which only exists when basalt_core does; its neighbour is pure geometry.
+    tests/test_win32_titlebar_actions.cpp)
+endif()
+
+# ---------------------------------------------------------------------------
+# Still to come:
+#
+#   mount_harness_win32     real ShadowViewMutations, no JavaScript, rendered
+#                           to a PNG -- the checkpoint between "the mounting
+#                           manager compiles" and "React Native runs".
+#   basalt_win32            a ReactHost, Hermes, and one surface in an HWND.
+#
+# And the components this platform does not claim yet: <ScrollView>, which
+# needs onScroll and scroll state, and <TextInput>, which needs an EDIT peer.
+# ---------------------------------------------------------------------------
+
+# Without React Native there is no basalt_core to link, and the harness calls
+# `basalt::installCrashHandler` whatever it is linked against -- so this build
+# compiles that one file itself. The MSBuild job in release.yml is the only
+# build that gets here, which is why the link error it answered with was
+# invisible to every CI run.
+if(NOT TARGET basalt_core)
+  list(APPEND BASALT_WIN32_TEST_SOURCES ${BASALT_CRASH_HANDLER})
+endif()
+
+add_executable(basalt_win32_tests ${BASALT_WIN32_TEST_SOURCES})
+target_compile_options(basalt_win32_tests PRIVATE ${BASALT_WIN32_WARNINGS})
+target_include_directories(basalt_win32_tests PRIVATE ${BASALT_TEST_INCLUDE})
+# basalt_win32_mounting already carries basalt_win32_view; naming both makes the
+# linker warn about a duplicate library rather than doing anything useful.
+if(TARGET basalt_win32_mounting)
+  target_link_libraries(basalt_win32_tests PRIVATE basalt_win32_mounting)
+  if(BASALT_PACKAGE_WIN32_LINK_LIBRARIES)
+    target_link_libraries(basalt_win32_tests PRIVATE ${BASALT_PACKAGE_WIN32_LINK_LIBRARIES})
+  endif()
+else()
+  target_link_libraries(basalt_win32_tests PRIVATE basalt_win32_view)
+endif()