@crossbind/core-app-host 0.0.0-bootstrap.0 → 2.0.0-beta.65

package/cpp/src/linux/main_thread.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <glib.h>
+
+#include <functional>
+
+// Runs fn on the GTK main loop: at once when the caller is on it, otherwise as soon as the loop gets to it.
+inline void onMainThread(std::function<void()> fn) {
+    g_main_context_invoke_full(
+        nullptr, G_PRIORITY_DEFAULT,
+        [](gpointer data) -> gboolean {
+            (*static_cast<std::function<void()> *>(data))();
+            return G_SOURCE_REMOVE;
+        },
+        new std::function<void()>(std::move(fn)), [](gpointer data) { delete static_cast<std::function<void()> *>(data); });
+}

package/cpp/src/linux/navigation.cpp

@@ -0,0 +1,55 @@
+#include "platform.h"
+
+#include <webkit2/webkit2.h>
+
+#include <algorithm>
+
+// A page from another origin in any frame would reach the module's channel and its crossbind:// routes, so the webview
+// never loads one. A link the user follows to such a page opens in the default browser instead.
+namespace {
+
+struct Lock {
+    std::vector<std::string> origins;
+    std::function<void()> newPage;
+};
+
+std::string originOf(const std::string &uri) {
+    const auto scheme = uri.find("://");
+    if (scheme == std::string::npos) return uri;
+    return uri.substr(0, uri.find_first_of("/?#", scheme + 3));
+}
+
+bool allows(const Lock &lock, const std::string &uri) {
+    if (uri.rfind("about:", 0) == 0) return true;
+    // A blob URL carries the origin of the page that made it.
+    if (uri.rfind("blob:", 0) == 0) return allows(lock, uri.substr(5));
+    return std::find(lock.origins.begin(), lock.origins.end(), originOf(uri)) != lock.origins.end();
+}
+
+gboolean onDecidePolicy(WebKitWebView *, WebKitPolicyDecision *decision, WebKitPolicyDecisionType type, gpointer data) {
+    if (type != WEBKIT_POLICY_DECISION_TYPE_NAVIGATION_ACTION && type != WEBKIT_POLICY_DECISION_TYPE_NEW_WINDOW_ACTION) return FALSE;
+    WebKitNavigationAction *action = webkit_navigation_policy_decision_get_navigation_action(WEBKIT_NAVIGATION_POLICY_DECISION(decision));
+    const char *requested = webkit_uri_request_get_uri(webkit_navigation_action_get_request(action));
+    const std::string uri = requested ? requested : "";
+    if (allows(*static_cast<Lock *>(data), uri)) return FALSE;
+    const bool followed = type == WEBKIT_POLICY_DECISION_TYPE_NEW_WINDOW_ACTION
+        || webkit_navigation_action_get_navigation_type(action) == WEBKIT_NAVIGATION_TYPE_LINK_CLICKED;
+    const std::string scheme = uri.substr(0, uri.find(':'));
+    if (followed && (scheme == "http" || scheme == "https" || scheme == "mailto")) {
+        g_app_info_launch_default_for_uri(uri.c_str(), nullptr, nullptr);
+    }
+    webkit_policy_decision_ignore(decision);
+    return TRUE;
+}
+
+void onLoadChanged(WebKitWebView *, WebKitLoadEvent event, gpointer data) {
+    if (event == WEBKIT_LOAD_COMMITTED) static_cast<Lock *>(data)->newPage();
+}
+
+}  // namespace
+
+void restrictNavigation(void *webView, std::vector<std::string> origins, std::function<void()> newPage) {
+    auto *lock = new Lock{std::move(origins), std::move(newPage)};
+    g_signal_connect(WEBKIT_WEB_VIEW(webView), "decide-policy", G_CALLBACK(onDecidePolicy), lock);
+    g_signal_connect(WEBKIT_WEB_VIEW(webView), "load-changed", G_CALLBACK(onLoadChanged), lock);
+}

package/cpp/src/main.cpp

@@ -0,0 +1,57 @@
+// A desktop app: a window with the system webview whose page reaches a crossbind module running in Hermes. The page
+// comes from crossbind://app/, or in the debug host the dev server opens, from the URL CROSSBIND_APP_URL names. Its
+// calls arrive as webview messages, their large bytes as crossbind:// request and response bodies.
+#include "app.h"
+#include "platform.h"
+#include "webview/webview.h"
+
+namespace {
+
+namespace app = crossbind::app;
+
+constexpr int WIDTH = 1024;
+constexpr int HEIGHT = 768;
+
+SchemeHandler schemeHandler;
+
+#ifdef __APPLE__
+// WKWebView takes its scheme handlers from the configuration it is made from.
+void configureWebView(void *configuration) { registerSchemeHandler(configuration, "crossbind", schemeHandler); }
+#elif defined(_WIN32)
+// WebView2 takes its schemes from the environment the webview is made in; a dev server's page requests the scheme too.
+// webview asks again on every attempt to make the environment, which keeps what it needs of them.
+std::vector<std::string> schemeOrigins;
+ICoreWebView2EnvironmentOptions *environmentOptions() {
+    static auto *options = static_cast<ICoreWebView2EnvironmentOptions *>(schemeEnvironmentOptions("crossbind", schemeOrigins));
+    return options;
+}
+#endif
+
+}  // namespace
+
+int main() {
+    const char *devUrl = app::devUrl();
+    app::Core &core = app::start(devUrl);
+    schemeHandler = [&core](SchemeRequest request, SchemeRespond respond) { core.serve(std::move(request), std::move(respond)); };
+
+#ifdef __APPLE__
+    webview::detail::cocoa_webkit::cocoa_configure_hook = configureWebView;
+#elif defined(_WIN32)
+    if (devUrl) schemeOrigins.push_back(app::originOf(devUrl));
+    webview::detail::win32_environment_options_hook = environmentOptions;
+#endif
+    webview::webview view(devUrl != nullptr, nullptr);
+    view.set_title(appName());
+    view.set_size(WIDTH, HEIGHT, WEBVIEW_HINT_NONE);
+    void *webView = view.browser_controller().value();
+#ifndef __APPLE__
+    registerSchemeHandler(webView, "crossbind", schemeHandler);
+#endif
+    const std::string url = app::attach(core, webView, devUrl);
+    // Quitting from the Dock or the system ends the app as closing its window does.
+    onQuit([&core] { app::quit(core, 0); });
+
+    view.navigate(url);
+    view.run();
+    app::quit(core, 0);
+}

package/cpp/src/platform.h

@@ -0,0 +1,57 @@
+#pragma once
+
+// What a platform gives the host: the webview's channels, its URL scheme, its navigation rule and where the app's
+// files are. darwin/ implements it with WKWebView on macOS and iOS (ios/ has the iOS app's own parts), linux/ with
+// WebKitGTK, windows/ with WebView2.
+#include <cstdint>
+#include <functional>
+#include <string>
+#include <utility>
+#include <vector>
+
+using ReplyFn = std::function<void(const std::string &)>;
+// A page message with the origin of the frame that sent it, empty where the webview does not tell it (WebKitGTK).
+// reply() may be called from any thread.
+using MessageHandler = std::function<void(std::string origin, std::string message, ReplyFn reply)>;
+
+struct SchemeRequest {
+    std::string method;
+    std::string path;
+    std::string query;
+    std::vector<uint8_t> body;
+};
+
+struct SchemeResponse {
+    int status = 200;
+    std::string mime = "application/octet-stream";
+    std::vector<uint8_t> body;
+    std::vector<std::pair<std::string, std::string>> headers;
+};
+
+using SchemeRespond = std::function<void(SchemeResponse)>;
+using SchemeHandler = std::function<void(SchemeRequest, SchemeRespond)>;
+
+// A message channel whose reply resolves the page's own postMessage() promise.
+void installReplyChannel(void *webView, const char *name, MessageHandler handler);
+// The page's console and uncaught errors, written to this process's output.
+void forwardConsole(void *webView);
+// Runs a script in the top frame of every page, before the page's own.
+void addTopFrameScript(void *webView, const std::string &source);
+// Serves <scheme>:// requests: on macOS of the webview made from this configuration, on Linux of this web view.
+// respond() may be called from any thread.
+void registerSchemeHandler(void *target, const char *scheme, SchemeHandler handler);
+// The webview loads only these origins, in any frame; a link to another opens in the default browser. newPage runs
+// when the main frame commits another document.
+void restrictNavigation(void *webView, std::vector<std::string> origins, std::function<void()> newPage);
+// Runs when the app is quit other than by closing its window (the Dock on macOS, the system on iOS), before it would
+// exit.
+void onQuit(std::function<void()> quit);
+// Where the app's files are, and its name.
+std::string resourceDir();
+std::string appName();
+
+#ifdef _WIN32
+// The ICoreWebView2EnvironmentOptions WebView2's environment is made with: they register the scheme, which pages of
+// these other origins may request as well.
+void *schemeEnvironmentOptions(const char *scheme, const std::vector<std::string> &origins);
+#endif

package/cpp/src/windows/app.cpp

@@ -0,0 +1,36 @@
+#include "platform.h"
+#include "windows/com.h"
+
+using namespace crossbind::windows;
+
+namespace {
+
+std::string executablePath() {
+    std::wstring path(MAX_PATH, L'\0');
+    for (;;) {
+        const DWORD length = GetModuleFileNameW(nullptr, path.data(), static_cast<DWORD>(path.size()));
+        if (length < path.size()) {
+            path.resize(length);
+            return utf8(path.c_str());
+        }
+        path.resize(path.size() * 2);
+    }
+}
+
+}  // namespace
+
+// A Windows app is a directory: the executable, and the app's files in resources\ beside it.
+std::string resourceDir() {
+    const std::string executable = executablePath();
+    return executable.substr(0, executable.find_last_of("\\/")) + "\\resources";
+}
+
+std::string appName() {
+    const std::string executable = executablePath();
+    std::string name = executable.substr(executable.find_last_of("\\/") + 1);
+    if (name.size() > 4 && name.compare(name.size() - 4, 4, ".exe") == 0) name.resize(name.size() - 4);
+    return name;
+}
+
+// The app ends with its window; anything else ends the process as it ends any other.
+void onQuit(std::function<void()>) {}

package/cpp/src/windows/app.manifest

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
+  <application xmlns="urn:schemas-microsoft-com:asm.v3">
+    <windowsSettings>
+      <activeCodePage xmlns="http://schemas.microsoft.com/SMI/2019/WindowsSettings">UTF-8</activeCodePage>
+    </windowsSettings>
+  </application>
+</assembly>

package/cpp/src/windows/app.rc

@@ -0,0 +1,3 @@
+// The app's manifest (resource 1 of type RT_MANIFEST) makes its narrow strings UTF-8: the paths and the environment
+// the host and the libraries it links pass to the C runtime and to Windows, such as a user folder with a non-ASCII name.
+1 24 "app.manifest"

package/cpp/src/windows/channels.cpp

@@ -0,0 +1,336 @@
+#include "platform.h"
+#include "windows/com.h"
+
+// crossbind's windows image writes it beside the SDK's headers.
+#include "crossbind_webview2.h"
+
+#include <shlwapi.h>
+
+#include <cstdio>
+#include <map>
+#include <memory>
+
+using namespace crossbind::windows;
+
+namespace {
+
+// The runtime the app declares itself compatible with, as the SDK's own options do: the one of the SDK it builds with.
+constexpr const wchar_t *TARGET_VERSION = CROSSBIND_WEBVIEW2_TARGET_VERSION;
+
+// WebView2's page messages answer nothing, so the page side of WebKit's reply channels is this script: a message
+// carries its channel's name and an id, and the reply comes back with the id. The host hears the top frame alone. An id
+// names its document too, so a reply meant for the page before a reload answers nothing in the next one.
+constexpr const char *CHANNELS_SCRIPT = R"js((() => {
+  const pending = new Map();
+  const session = crypto.getRandomValues(new Uint32Array(2)).join('-');
+  let next = 0;
+  const handlers = {};
+  Object.defineProperty(globalThis, 'webkit', { value: { messageHandlers: handlers } });
+  Object.defineProperty(globalThis, '__crossbind_channel', { value: (name) => {
+    handlers[name] = {
+      postMessage: (text) => new Promise((resolve) => {
+        const id = `${session}.${++next}`;
+        pending.set(id, resolve);
+        chrome.webview.postMessage(`${name}\n${id}\n${text}`);
+      }),
+    };
+  } });
+  chrome.webview.addEventListener('message', (event) => {
+    const text = String(event.data);
+    const cut = text.indexOf('\n');
+    const id = text.slice(0, cut);
+    pending.get(id)?.(text.slice(cut + 1));
+    pending.delete(id);
+  });
+})();)js";
+
+// Wraps the page's console and reports uncaught errors.
+constexpr const char *CONSOLE_SCRIPT = R"js((() => {
+  const text = (args) => args.map((arg) => {
+    if (arg instanceof Error) return `${arg.message}\n${arg.stack}`;
+    if (typeof arg === 'string') return arg;
+    try { return JSON.stringify(arg); } catch { return String(arg); }
+  }).join(' ');
+  const post = (level, args) => chrome.webview.postMessage(`crossbind_console\n0\n${level}\n${text(args)}`);
+  for (const level of ['log', 'info', 'warn', 'error', 'debug']) {
+    const original = console[level].bind(console);
+    console[level] = (...args) => { post(level, args); original(...args); };
+  }
+  addEventListener('error', (event) => post('error', [event.error ?? event.message]));
+  addEventListener('unhandledrejection', (event) => post('error', [event.reason]));
+})();)js";
+
+std::map<std::string, MessageHandler> &handlers() {
+    static auto *all = new std::map<std::string, MessageHandler>();
+    return *all;
+}
+
+std::string originOf(const std::string &url) {
+    const auto scheme = url.find("://");
+    if (scheme == std::string::npos) return url;
+    return url.substr(0, url.find_first_of("/?#", scheme + 3));
+}
+
+// WebView2 adds a script later; the UI thread waits for it, as webview's own scripts do, so the first page gets it.
+void addScript(ICoreWebView2 *core, const std::string &source) {
+    auto added = std::make_shared<bool>(false);
+    auto *done = new Handler<ICoreWebView2AddScriptToExecuteOnDocumentCreatedCompletedHandler, HRESULT, LPCWSTR>(
+        IID_ICoreWebView2AddScriptToExecuteOnDocumentCreatedCompletedHandler, [added](HRESULT, LPCWSTR) -> HRESULT {
+            *added = true;
+            return S_OK;
+        });
+    if (SUCCEEDED(core->AddScriptToExecuteOnDocumentCreated(wide("if (window === window.top) {\n" + source + "\n}").c_str(), done))) {
+        MSG message;
+        while (!*added) {
+            const BOOL got = GetMessageW(&message, nullptr, 0, 0);
+            // The window closed meanwhile: the app's own loop gets the quit as well.
+            if (got == 0) PostQuitMessage(static_cast<int>(message.wParam));
+            if (got <= 0) break;
+            TranslateMessage(&message);
+            DispatchMessageW(&message);
+        }
+    }
+    done->Release();
+}
+
+void listen(ICoreWebView2 *core) {
+    static bool listening = false;
+    if (listening) return;
+    listening = true;
+    addScript(core, CHANNELS_SCRIPT);
+    auto *received = new Handler<ICoreWebView2WebMessageReceivedEventHandler, ICoreWebView2 *, ICoreWebView2WebMessageReceivedEventArgs *>(
+        IID_ICoreWebView2WebMessageReceivedEventHandler, [core](ICoreWebView2 *, ICoreWebView2WebMessageReceivedEventArgs *args) -> HRESULT {
+            LPWSTR raw = nullptr;
+            if (FAILED(args->TryGetWebMessageAsString(&raw))) return S_OK;
+            const std::string text = take(raw);
+            const size_t first = text.find('\n');
+            const size_t second = first == std::string::npos ? first : text.find('\n', first + 1);
+            if (second == std::string::npos) return S_OK;
+            const auto handler = handlers().find(text.substr(0, first));
+            if (handler == handlers().end()) return S_OK;
+            LPWSTR source = nullptr;
+            // A sender WebView2 cannot name is no origin a page may call from.
+            const std::string origin = SUCCEEDED(args->get_Source(&source)) ? originOf(take(source)) : "null";
+            const std::string id = text.substr(first + 1, second - first - 1);
+            handler->second(origin, text.substr(second + 1), [core, id](const std::string &reply) {
+                onMainThread([core, message = wide(id + "\n" + reply)] { core->PostWebMessageAsString(message.c_str()); });
+            });
+            return S_OK;
+        });
+    EventRegistrationToken token;
+    core->add_WebMessageReceived(received, &token);
+    received->Release();
+}
+
+std::vector<uint8_t> readAll(IStream *stream) {
+    std::vector<uint8_t> body;
+    uint8_t chunk[65536];
+    for (ULONG read = 0; SUCCEEDED(stream->Read(chunk, sizeof chunk, &read)) && read > 0;) body.insert(body.end(), chunk, chunk + read);
+    return body;
+}
+
+const wchar_t *reasonOf(int status) {
+    switch (status) {
+    case 200: return L"OK";
+    case 204: return L"No Content";
+    case 403: return L"Forbidden";
+    case 404: return L"Not Found";
+    default: return status < 400 ? L"OK" : L"Error";
+    }
+}
+
+class SchemeRegistration final : public ICoreWebView2CustomSchemeRegistration {
+public:
+    SchemeRegistration(std::wstring scheme, std::vector<std::wstring> origins) : scheme_(std::move(scheme)), origins_(std::move(origins)) {}
+
+    ULONG STDMETHODCALLTYPE AddRef() override { return ++refs_; }
+    ULONG STDMETHODCALLTYPE Release() override {
+        const ULONG left = --refs_;
+        if (left == 0) delete this;
+        return left;
+    }
+    HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **out) override {
+        if (!out) return E_POINTER;
+        if (!IsEqualIID(riid, IID_IUnknown) && !IsEqualIID(riid, IID_ICoreWebView2CustomSchemeRegistration)) {
+            *out = nullptr;
+            return E_NOINTERFACE;
+        }
+        *out = static_cast<ICoreWebView2CustomSchemeRegistration *>(this);
+        AddRef();
+        return S_OK;
+    }
+    HRESULT STDMETHODCALLTYPE get_SchemeName(LPWSTR *name) override {
+        *name = give(scheme_);
+        return S_OK;
+    }
+    // Its pages are secure contexts, as https pages are.
+    HRESULT STDMETHODCALLTYPE get_TreatAsSecure(BOOL *value) override {
+        *value = TRUE;
+        return S_OK;
+    }
+    HRESULT STDMETHODCALLTYPE put_TreatAsSecure(BOOL) override { return E_NOTIMPL; }
+    HRESULT STDMETHODCALLTYPE GetAllowedOrigins(UINT32 *count, LPWSTR **origins) override {
+        *count = static_cast<UINT32>(origins_.size());
+        *origins = static_cast<LPWSTR *>(CoTaskMemAlloc(sizeof(LPWSTR) * (origins_.size() + 1)));
+        for (size_t i = 0; i < origins_.size(); ++i) (*origins)[i] = give(origins_[i]);
+        return S_OK;
+    }
+    HRESULT STDMETHODCALLTYPE SetAllowedOrigins(UINT32, LPCWSTR *) override { return E_NOTIMPL; }
+    // crossbind://app is an origin of its own.
+    HRESULT STDMETHODCALLTYPE get_HasAuthorityComponent(BOOL *value) override {
+        *value = TRUE;
+        return S_OK;
+    }
+    HRESULT STDMETHODCALLTYPE put_HasAuthorityComponent(BOOL) override { return E_NOTIMPL; }
+
+private:
+    std::atomic<ULONG> refs_{1};
+    std::wstring scheme_;
+    std::vector<std::wstring> origins_;
+};
+
+class EnvironmentOptions final : public ICoreWebView2EnvironmentOptions, public ICoreWebView2EnvironmentOptions4 {
+public:
+    explicit EnvironmentOptions(ICoreWebView2CustomSchemeRegistration *scheme) : scheme_(scheme) {}
+    ~EnvironmentOptions() { scheme_->Release(); }
+
+    ULONG STDMETHODCALLTYPE AddRef() override { return ++refs_; }
+    ULONG STDMETHODCALLTYPE Release() override {
+        const ULONG left = --refs_;
+        if (left == 0) delete this;
+        return left;
+    }
+    HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **out) override {
+        if (!out) return E_POINTER;
+        if (IsEqualIID(riid, IID_IUnknown) || IsEqualIID(riid, IID_ICoreWebView2EnvironmentOptions)) {
+            *out = static_cast<ICoreWebView2EnvironmentOptions *>(this);
+        } else if (IsEqualIID(riid, IID_ICoreWebView2EnvironmentOptions4)) {
+            *out = static_cast<ICoreWebView2EnvironmentOptions4 *>(this);
+        } else {
+            *out = nullptr;
+            return E_NOINTERFACE;
+        }
+        AddRef();
+        return S_OK;
+    }
+    HRESULT STDMETHODCALLTYPE get_AdditionalBrowserArguments(LPWSTR *value) override {
+        *value = nullptr;
+        return S_OK;
+    }
+    HRESULT STDMETHODCALLTYPE put_AdditionalBrowserArguments(LPCWSTR) override { return E_NOTIMPL; }
+    HRESULT STDMETHODCALLTYPE get_Language(LPWSTR *value) override {
+        *value = nullptr;
+        return S_OK;
+    }
+    HRESULT STDMETHODCALLTYPE put_Language(LPCWSTR) override { return E_NOTIMPL; }
+    HRESULT STDMETHODCALLTYPE get_TargetCompatibleBrowserVersion(LPWSTR *value) override {
+        *value = give(TARGET_VERSION);
+        return S_OK;
+    }
+    HRESULT STDMETHODCALLTYPE put_TargetCompatibleBrowserVersion(LPCWSTR) override { return E_NOTIMPL; }
+    HRESULT STDMETHODCALLTYPE get_AllowSingleSignOnUsingOSPrimaryAccount(BOOL *allow) override {
+        *allow = FALSE;
+        return S_OK;
+    }
+    HRESULT STDMETHODCALLTYPE put_AllowSingleSignOnUsingOSPrimaryAccount(BOOL) override { return E_NOTIMPL; }
+    HRESULT STDMETHODCALLTYPE GetCustomSchemeRegistrations(UINT32 *count, ICoreWebView2CustomSchemeRegistration ***registrations) override {
+        *count = 1;
+        *registrations = static_cast<ICoreWebView2CustomSchemeRegistration **>(CoTaskMemAlloc(sizeof(ICoreWebView2CustomSchemeRegistration *)));
+        (*registrations)[0] = scheme_;
+        scheme_->AddRef();
+        return S_OK;
+    }
+    HRESULT STDMETHODCALLTYPE SetCustomSchemeRegistrations(UINT32, ICoreWebView2CustomSchemeRegistration **) override { return E_NOTIMPL; }
+
+private:
+    std::atomic<ULONG> refs_{1};
+    ICoreWebView2CustomSchemeRegistration *scheme_;
+};
+
+}  // namespace
+
+void *schemeEnvironmentOptions(const char *scheme, const std::vector<std::string> &origins) {
+    std::vector<std::wstring> allowed;
+    for (const auto &origin : origins) allowed.push_back(wide(origin));
+    return static_cast<ICoreWebView2EnvironmentOptions *>(new EnvironmentOptions(new SchemeRegistration(wide(scheme), std::move(allowed))));
+}
+
+void installReplyChannel(void *webView, const char *name, MessageHandler handler) {
+    ICoreWebView2 *core = coreWebView(webView);
+    listen(core);
+    handlers()[name] = std::move(handler);
+    addScript(core, std::string("__crossbind_channel('") + name + "');");
+}
+
+void forwardConsole(void *webView) {
+    ICoreWebView2 *core = coreWebView(webView);
+    listen(core);
+    handlers()["crossbind_console"] = [](std::string, std::string message, ReplyFn) {
+        const size_t cut = message.find('\n');
+        const std::string level = message.substr(0, cut);
+        std::FILE *out = level == "warn" || level == "error" ? stderr : stdout;
+        std::fprintf(out, "%s\n", cut == std::string::npos ? "" : message.c_str() + cut + 1);
+        std::fflush(out);
+    };
+    addScript(core, CONSOLE_SCRIPT);
+}
+
+void addTopFrameScript(void *webView, const std::string &source) { addScript(coreWebView(webView), source); }
+
+// The scheme itself is registered with the environment (schemeEnvironmentOptions); this serves its requests.
+void registerSchemeHandler(void *target, const char *scheme, SchemeHandler handler) {
+    ICoreWebView2 *core = coreWebView(target);
+    ICoreWebView2_2 *core2 = nullptr;
+    core->QueryInterface(IID_ICoreWebView2_2, reinterpret_cast<void **>(&core2));
+    ICoreWebView2Environment *environment = nullptr;
+    core2->get_Environment(&environment);
+    core2->Release();
+    core->AddWebResourceRequestedFilter(wide(std::string(scheme) + "://*").c_str(), COREWEBVIEW2_WEB_RESOURCE_CONTEXT_ALL);
+    auto *serve = new SchemeHandler(std::move(handler));
+    auto *requested = new Handler<ICoreWebView2WebResourceRequestedEventHandler, ICoreWebView2 *, ICoreWebView2WebResourceRequestedEventArgs *>(
+        IID_ICoreWebView2WebResourceRequestedEventHandler,
+        [serve, environment](ICoreWebView2 *, ICoreWebView2WebResourceRequestedEventArgs *args) -> HRESULT {
+            ICoreWebView2WebResourceRequest *request = nullptr;
+            if (FAILED(args->get_Request(&request))) return S_OK;
+            SchemeRequest incoming;
+            LPWSTR method = nullptr;
+            request->get_Method(&method);
+            incoming.method = take(method);
+            LPWSTR uri = nullptr;
+            request->get_Uri(&uri);
+            const std::string url = take(uri);
+            const size_t authority = url.find("://");
+            const size_t path = url.find('/', authority == std::string::npos ? 0 : authority + 3);
+            const size_t query = url.find('?', path == std::string::npos ? 0 : path);
+            incoming.path = path == std::string::npos ? "/" : url.substr(path, query == std::string::npos ? std::string::npos : query - path);
+            incoming.query = query == std::string::npos ? "" : url.substr(query + 1, url.find('#', query) - query - 1);
+            IStream *content = nullptr;
+            if (SUCCEEDED(request->get_Content(&content)) && content) {
+                incoming.body = readAll(content);
+                content->Release();
+            }
+            request->Release();
+            ICoreWebView2Deferral *deferral = nullptr;
+            args->GetDeferral(&deferral);
+            args->AddRef();
+            (*serve)(std::move(incoming), [args, deferral, environment](SchemeResponse response) {
+                onMainThread([args, deferral, environment, response = std::move(response)] {
+                    IStream *body = SHCreateMemStream(response.body.data(), static_cast<UINT>(response.body.size()));
+                    std::string headers = "Content-Type: " + response.mime;
+                    for (const auto &[name, value] : response.headers) headers += "\r\n" + name + ": " + value;
+                    ICoreWebView2WebResourceResponse *answer = nullptr;
+                    environment->CreateWebResourceResponse(body, response.status, reasonOf(response.status), wide(headers).c_str(), &answer);
+                    args->put_Response(answer);
+                    deferral->Complete();
+                    if (answer) answer->Release();
+                    if (body) body->Release();
+                    deferral->Release();
+                    args->Release();
+                });
+            });
+            return S_OK;
+        });
+    EventRegistrationToken token;
+    core->add_WebResourceRequested(requested, &token);
+    requested->Release();
+}

package/cpp/src/windows/com.cpp

@@ -0,0 +1,92 @@
+#include "windows/com.h"
+
+#include <cstring>
+#include <deque>
+#include <mutex>
+
+namespace crossbind::windows {
+
+namespace {
+
+constexpr UINT RUN = WM_APP + 1;
+DWORD uiThread = 0;
+HWND dispatcher = nullptr;
+std::mutex queueMutex;
+std::deque<std::function<void()>> queue;
+
+LRESULT CALLBACK dispatch(HWND window, UINT message, WPARAM wParam, LPARAM lParam) {
+    if (message != RUN) return DefWindowProcW(window, message, wParam, lParam);
+    std::deque<std::function<void()>> tasks;
+    {
+        std::lock_guard<std::mutex> lock(queueMutex);
+        tasks.swap(queue);
+    }
+    for (auto &task : tasks) task();
+    return 0;
+}
+
+// A message-only window of the UI thread, whose message loop runs what other threads post to it.
+void startDispatcher() {
+    uiThread = GetCurrentThreadId();
+    WNDCLASSW type{};
+    type.lpfnWndProc = dispatch;
+    type.hInstance = GetModuleHandleW(nullptr);
+    type.lpszClassName = L"crossbind_dispatcher";
+    RegisterClassW(&type);
+    dispatcher = CreateWindowExW(0, type.lpszClassName, L"", 0, 0, 0, 0, 0, HWND_MESSAGE, nullptr, type.hInstance, nullptr);
+}
+
+}  // namespace
+
+std::wstring wide(const std::string &text) {
+    if (text.empty()) return {};
+    const int size = MultiByteToWideChar(CP_UTF8, 0, text.data(), static_cast<int>(text.size()), nullptr, 0);
+    std::wstring result(static_cast<size_t>(size), L'\0');
+    MultiByteToWideChar(CP_UTF8, 0, text.data(), static_cast<int>(text.size()), result.data(), size);
+    return result;
+}
+
+std::string utf8(const wchar_t *text) {
+    if (!text || !*text) return {};
+    const int size = WideCharToMultiByte(CP_UTF8, 0, text, -1, nullptr, 0, nullptr, nullptr);
+    std::string result(static_cast<size_t>(size - 1), '\0');
+    WideCharToMultiByte(CP_UTF8, 0, text, -1, result.data(), size, nullptr, nullptr);
+    return result;
+}
+
+std::string take(LPWSTR text) {
+    std::string result = utf8(text);
+    CoTaskMemFree(text);
+    return result;
+}
+
+LPWSTR give(const std::wstring &text) {
+    auto *copy = static_cast<LPWSTR>(CoTaskMemAlloc((text.size() + 1) * sizeof(wchar_t)));
+    if (copy) std::memcpy(copy, text.c_str(), (text.size() + 1) * sizeof(wchar_t));
+    return copy;
+}
+
+// The platform's calls all start here, on the UI thread, before any other thread posts to it.
+ICoreWebView2 *coreWebView(void *controller) {
+    if (!dispatcher) startDispatcher();
+    ICoreWebView2 *core = nullptr;
+    static_cast<ICoreWebView2Controller *>(controller)->get_CoreWebView2(&core);
+    return core;
+}
+
+// What other threads post waits in one queue, which one message drains: Windows caps the messages a thread has posted.
+void onMainThread(std::function<void()> fn) {
+    if (GetCurrentThreadId() == uiThread) {
+        fn();
+        return;
+    }
+    bool isIdle;
+    {
+        std::lock_guard<std::mutex> lock(queueMutex);
+        isIdle = queue.empty();
+        queue.push_back(std::move(fn));
+    }
+    if (isIdle) PostMessageW(dispatcher, RUN, 0, 0);
+}
+
+}  // namespace crossbind::windows