diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 7f23e6a..d53b469 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1,129 +1,47 @@
-name: ci
+name: CI
 
 on:
   push:
+    branches:
+      - "**"
   pull_request:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ci-${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
 
 jobs:
-  matrix:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
+  build-and-test:
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
 
     steps:
       - name: Checkout
         uses: actions/checkout@v4
 
       - name: Setup Zig
-        shell: bash
-        env:
-          ZIG_VERSION: 0.15.2
-        run: |
-          set -euo pipefail
-          python - <<'PY'
-          import hashlib
-          import json
-          import os
-          import pathlib
-          import shutil
-          import tarfile
-          import urllib.request
-          import zipfile
-
-          version = os.environ["ZIG_VERSION"]
-          runner_os = os.environ["RUNNER_OS"]
-          runner_arch = os.environ["RUNNER_ARCH"]
-
-          os_map = {
-              "Linux": "linux",
-              "macOS": "macos",
-              "Windows": "windows",
-          }
-          arch_map = {
-              "X64": "x86_64",
-              "ARM64": "aarch64",
-              "X86": "x86",
-          }
-
-          os_part = os_map.get(runner_os)
-          arch_part = arch_map.get(runner_arch.upper())
-          if os_part is None or arch_part is None:
-              raise SystemExit(
-                  f"Unsupported runner combination RUNNER_OS={runner_os} RUNNER_ARCH={runner_arch}"
-              )
-
-          artifact_key = f"{arch_part}-{os_part}"
-          with urllib.request.urlopen("https://ziglang.org/download/index.json") as resp:
-              index = json.load(resp)
-
-          release = index.get(version)
-          if release is None:
-              raise SystemExit(f"Zig version {version} is not present in ziglang download index")
-
-          artifact = release.get(artifact_key)
-          if artifact is None:
-              raise SystemExit(f"No Zig artifact for key {artifact_key} in version {version}")
-
-          tarball_url = artifact["tarball"]
-          expected_sha256 = artifact["shasum"]
-
-          out_root = pathlib.Path(os.environ["RUNNER_TEMP"]) / f"zig-{version}-{artifact_key}"
-          if out_root.exists():
-              shutil.rmtree(out_root)
-          out_root.mkdir(parents=True)
-
-          archive_path = out_root / pathlib.Path(tarball_url).name
-          print(f"Downloading {tarball_url}", flush=True)
-          urllib.request.urlretrieve(tarball_url, archive_path)
-
-          digest = hashlib.sha256()
-          with archive_path.open("rb") as f:
-              for chunk in iter(lambda: f.read(1024 * 1024), b""):
-                  digest.update(chunk)
-          actual_sha256 = digest.hexdigest()
-          if actual_sha256.lower() != expected_sha256.lower():
-              raise SystemExit(
-                  f"SHA256 mismatch for {archive_path.name}: {actual_sha256} != {expected_sha256}"
-              )
-
-          extract_dir = out_root / "extract"
-          extract_dir.mkdir()
-          lower_name = archive_path.name.lower()
-          if lower_name.endswith(".zip"):
-              with zipfile.ZipFile(archive_path) as zf:
-                  zf.extractall(extract_dir)
-          else:
-              with tarfile.open(archive_path, "r:*") as tf:
-                  tf.extractall(extract_dir)
-
-          dirs = [p for p in extract_dir.iterdir() if p.is_dir()]
-          if len(dirs) == 1:
-              zig_root = dirs[0]
-          else:
-              candidates = [p for p in extract_dir.rglob("*") if p.is_file() and p.name in ("zig", "zig.exe")]
-              if not candidates:
-                  raise SystemExit("Unable to locate zig executable after extraction")
-              exe = candidates[0]
-              zig_root = exe.parent.parent if exe.parent.name == "bin" else exe.parent
-
-          zig_exe_name = "zig.exe" if runner_os == "Windows" else "zig"
-          zig_path = zig_root / zig_exe_name
-          if not zig_path.exists():
-              zig_path = zig_root / "bin" / zig_exe_name
-          if not zig_path.exists():
-              raise SystemExit(f"Unable to find zig executable under {zig_root}")
-
-          with pathlib.Path(os.environ["GITHUB_PATH"]).open("a", encoding="utf-8") as f:
-              f.write(str(zig_path.parent) + "\n")
-
-          print(f"Installed Zig {version} at {zig_path}", flush=True)
-          PY
+        uses: mlugg/setup-zig@v2
+        with:
+          version: master
+          cache-key: ${{ runner.os }}-${{ hashFiles('build.zig', 'build.zig.zon') }}
 
       - name: Zig Version
         run: zig version
 
+      - name: Format Check
+        shell: bash
+        run: |
+          files=$(find . -type f -name '*.zig' \
+            -not -path './.zig-cache/*' \
+            -not -path './.zig-cache-*/*' \
+            -not -path './.zig-global-cache/*' \
+            -not -path './zig-out/*')
+          zig fmt --check $files
+
       - name: Build
         run: zig build
 
diff --git a/.gitignore b/.gitignore
index b932c1a..b425636 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,8 @@
 .zig-cache/
+.zig-cache-global/
+.zig-cache-local/
+zig-pkg/
+.scratch/
 zig-out/
 zig-out-clean-dyn/
 zig-out-clean-macos-dyn/
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 8bb011e..48e4fc4 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -4,7 +4,8 @@ Thanks for contributing to WebUI Zig.
 
 ## Development Setup
 
-- Zig `0.15.2+` (see `build.zig.zon`)
+- Zig `0.16.0-dev.2984+cb7d2b056` or newer
+- CI tracks Zig `master` via `mlugg/setup-zig`
 - Linux, macOS, or Windows
 
 Core commands:
diff --git a/README.md b/README.md
index dfbb370..d1c4802 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
 
 A Zig-first WebUI runtime with typed RPC, deterministic launch policy, native host launch paths, and browser/web fallbacks.
 
-![Zig](https://img.shields.io/badge/Zig-0.15.2%2B-f7a41d)
+![Zig](https://img.shields.io/badge/Zig-0.16--dev%20%2F%20master-f7a41d)
 ![Platforms](https://img.shields.io/badge/Platforms-Linux%20%7C%20macOS%20%7C%20Windows-2ea44f)
 ![Mode](https://img.shields.io/badge/Transport-WebView%20%2B%20Browser%20%2B%20Web-0366d6)
 
diff --git a/build.zig b/build.zig
index 719cfac..c1f2cbb 100644
--- a/build.zig
+++ b/build.zig
@@ -135,6 +135,7 @@ const examples = [_]Example{
     },
 };
 
+/// Configures the library, examples, tests, generated bridge assets, and helper build steps.
 pub fn build(b: *Build) void {
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
@@ -144,6 +145,7 @@ pub fn build(b: *Build) void {
     const enable_webui_log = b.option(bool, "enable-webui-log", "Enable runtime log defaults") orelse false;
     const minify_embedded_js = b.option(bool, "minify-embedded-js", "Minify embedded JS helpers with pure Zig asset processing (default: true)") orelse true;
     const minify_written_js = b.option(bool, "minify-written-js", "Minify written JS helper assets with pure Zig asset processing (default: false)") orelse false;
+    const test_filter = b.option([]const u8, "test-filter", "Optional compile-time test name filter for `zig build test`");
     const selected_example = b.option(ExampleChoice, "example", "Example to run with `zig build run` (default: all)") orelse .all;
     const run_mode_option = b.option([]const u8, "run-mode", "Runtime launch order for examples. Presets: `webview`, `browser` (app-window), `web-tab`, `web-url`. Or ordered tokens (`webview,browser,web-url`, `browser,webview`, etc). Default: webview,browser,web-url");
     const run_mode = run_mode_option orelse "webview,browser,web-url";
@@ -168,19 +170,46 @@ pub fn build(b: *Build) void {
     build_opts.addOption([]const u8, "runtime_helpers_embed_path", runtime_helpers_assets.embed_path);
     build_opts.addOption([]const u8, "runtime_helpers_written_path", runtime_helpers_assets.written_path);
 
-    const websocket_dep = b.dependency("websocket", .{
+    const zhttp_dep = b.dependency("zhttp", .{
         .target = target,
         .optimize = optimize,
     });
-    const websocket_mod = websocket_dep.module("websocket");
+    const zhttp_mod = zhttp_dep.module("zhttp");
+    const zhttp_request_mod = b.createModule(.{
+        .root_source_file = zhttp_dep.path("src/request.zig"),
+        .target = target,
+        .optimize = optimize,
+        .link_libc = false,
+    });
     const tls_dep = b.dependency("tls", .{
         .target = target,
         .optimize = optimize,
     });
     const tls_mod = tls_dep.module("tls");
-    const websocket_build_opts = b.addOptions();
-    websocket_build_opts.addOption(bool, "websocket_blocking", false);
-    websocket_mod.addOptions("build", websocket_build_opts);
+    const time_compat_mod = b.createModule(.{
+        .root_source_file = b.path("src/time_compat.zig"),
+        .target = target,
+        .optimize = optimize,
+        .link_libc = false,
+    });
+    const thread_compat_mod = b.createModule(.{
+        .root_source_file = b.path("src/thread_compat.zig"),
+        .target = target,
+        .optimize = optimize,
+        .link_libc = false,
+    });
+    const env_compat_mod = b.createModule(.{
+        .root_source_file = b.path("src/env_compat.zig"),
+        .target = target,
+        .optimize = optimize,
+        .link_libc = false,
+    });
+    const io_compat_mod = b.createModule(.{
+        .root_source_file = b.path("src/io_compat.zig"),
+        .target = target,
+        .optimize = optimize,
+        .link_libc = false,
+    });
 
     const lib_module = b.createModule(.{
         .root_source_file = b.path("src/root.zig"),
@@ -189,8 +218,13 @@ pub fn build(b: *Build) void {
         .link_libc = false,
     });
     lib_module.addOptions("build_options", build_opts);
-    lib_module.addImport("websocket", websocket_mod);
+    lib_module.addImport("zhttp", zhttp_mod);
+    lib_module.addImport("zhttp_request", zhttp_request_mod);
     lib_module.addImport("tls", tls_mod);
+    lib_module.addImport("time_compat", time_compat_mod);
+    lib_module.addImport("thread_compat", thread_compat_mod);
+    lib_module.addImport("env_compat", env_compat_mod);
+    lib_module.addImport("io_compat", io_compat_mod);
 
     const webui_lib = b.addLibrary(.{
         .name = "webui",
@@ -207,17 +241,40 @@ pub fn build(b: *Build) void {
         .link_libc = false,
     });
     webui_mod.addOptions("build_options", build_opts);
-    webui_mod.addImport("websocket", websocket_mod);
+    webui_mod.addImport("zhttp", zhttp_mod);
+    webui_mod.addImport("zhttp_request", zhttp_request_mod);
     webui_mod.addImport("tls", tls_mod);
+    webui_mod.addImport("time_compat", time_compat_mod);
+    webui_mod.addImport("thread_compat", thread_compat_mod);
+    webui_mod.addImport("env_compat", env_compat_mod);
+    webui_mod.addImport("io_compat", io_compat_mod);
+
+    const example_links_libc = target.result.os.tag == .linux;
+    const webui_examples_mod = b.addModule("webui_examples", .{
+        .root_source_file = b.path("src/root.zig"),
+        .target = target,
+        .optimize = optimize,
+        .link_libc = example_links_libc,
+    });
+    webui_examples_mod.addOptions("build_options", build_opts);
+    webui_examples_mod.addImport("zhttp", zhttp_mod);
+    webui_examples_mod.addImport("zhttp_request", zhttp_request_mod);
+    webui_examples_mod.addImport("tls", tls_mod);
+    webui_examples_mod.addImport("time_compat", time_compat_mod);
+    webui_examples_mod.addImport("thread_compat", thread_compat_mod);
+    webui_examples_mod.addImport("env_compat", env_compat_mod);
+    webui_examples_mod.addImport("io_compat", io_compat_mod);
 
     const example_shared_source_path = "examples/shared/demo_runner.zig";
     const example_shared_mod: ?*Build.Module = if (pathExists(example_shared_source_path)) b.addModule("example_shared", .{
         .root_source_file = b.path(example_shared_source_path),
         .target = target,
         .optimize = optimize,
-        .link_libc = false,
+        .link_libc = example_links_libc,
         .imports = &.{
-            .{ .name = "webui", .module = webui_mod },
+            .{ .name = "webui", .module = webui_examples_mod },
+            .{ .name = "time_compat", .module = time_compat_mod },
+            .{ .name = "env_compat", .module = env_compat_mod },
         },
     }) else null;
 
@@ -230,14 +287,17 @@ pub fn build(b: *Build) void {
             .link_libc = false,
             .imports = &.{
                 .{ .name = "webui", .module = webui_mod },
+                .{ .name = "time_compat", .module = time_compat_mod },
+                .{ .name = "io_compat", .module = io_compat_mod },
             },
         }),
     });
     exe.step.dependOn(runtime_helpers_assets.prepare_step);
-    exe.linkLibrary(webui_lib);
+    exe.root_module.linkLibrary(webui_lib);
     b.installArtifact(exe);
 
     const run_step = b.step("run", "Run Zig examples (default: all, override with -Dexample=<name>)");
+    const test_filters: []const []const u8 = if (test_filter) |name| &.{name} else &.{};
 
     const bridge_template_mod = b.createModule(.{
         .root_source_file = b.path("src/bridge/template.zig"),
@@ -289,7 +349,7 @@ pub fn build(b: *Build) void {
         for (examples) |example| {
             if (!pathExists(example.source_path)) continue;
 
-            const built = addExample(b, example, webui_mod, shared_mod, webui_lib, target, optimize, runtime_helpers_assets.prepare_step);
+            const built = addExample(b, example, webui_examples_mod, shared_mod, webui_lib, target, optimize, runtime_helpers_assets.prepare_step, example_links_libc);
             examples_step.dependOn(built.install_step);
 
             if (selected_example == .all or selected_example == example.selector) {
@@ -323,11 +383,14 @@ pub fn build(b: *Build) void {
             .link_libc = false,
             .imports = &.{
                 .{ .name = "webui", .module = webui_mod },
+                .{ .name = "time_compat", .module = time_compat_mod },
+                .{ .name = "io_compat", .module = io_compat_mod },
             },
         }),
+        .filters = test_filters,
     });
     mod_tests.step.dependOn(runtime_helpers_assets.prepare_step);
-    mod_tests.linkLibrary(webui_lib);
+    mod_tests.root_module.linkLibrary(webui_lib);
     const run_mod_tests = b.addRunArtifact(mod_tests);
 
     var run_example_shared_tests_step: ?*Build.Step = null;
@@ -337,15 +400,18 @@ pub fn build(b: *Build) void {
                 .root_source_file = b.path(example_shared_source_path),
                 .target = target,
                 .optimize = optimize,
-                .link_libc = false,
+                .link_libc = example_links_libc,
                 .imports = &.{
-                    .{ .name = "webui", .module = webui_mod },
+                    .{ .name = "webui", .module = webui_examples_mod },
                     .{ .name = "example_shared", .module = shared_mod },
+                    .{ .name = "time_compat", .module = time_compat_mod },
+                    .{ .name = "env_compat", .module = env_compat_mod },
                 },
             }),
+            .filters = test_filters,
         });
         example_shared_tests.step.dependOn(runtime_helpers_assets.prepare_step);
-        example_shared_tests.linkLibrary(webui_lib);
+        example_shared_tests.root_module.linkLibrary(webui_lib);
         const run_example_shared_tests = b.addRunArtifact(example_shared_tests);
         run_example_shared_tests_step = &run_example_shared_tests.step;
     }
@@ -361,7 +427,7 @@ pub fn build(b: *Build) void {
         .filters = &.{"threaded dispatcher stress"},
     });
     dispatcher_stress_tests.step.dependOn(runtime_helpers_assets.prepare_step);
-    dispatcher_stress_tests.linkLibrary(webui_lib);
+    dispatcher_stress_tests.root_module.linkLibrary(webui_lib);
 
     const dispatcher_stress_step = b.step("dispatcher-stress", "Stress threaded dispatcher concurrency/lifetime paths");
     var stress_iter: usize = 0;
@@ -389,23 +455,23 @@ pub fn build(b: *Build) void {
         "bash",
         "-lc",
         \\set -euo pipefail
-        \\if rg -n "@cImport" src tools examples >/dev/null 2>&1; then
+        \\if grep -R -n -E "@cImport" src tools examples >/dev/null 2>&1; then
         \\  echo "static-guard failed: found @cImport in active sources" >&2
         \\  exit 1
         \\fi
-        \\if rg -n "addCSourceFile" src tools examples >/dev/null 2>&1; then
+        \\if grep -R -n -E "addCSourceFile" src tools examples >/dev/null 2>&1; then
         \\  echo "static-guard failed: found addCSourceFile in active sources" >&2
         \\  exit 1
         \\fi
-        \\if rg -n "translate-c|std\\.zig\\.c_translation|src/translated" src tools examples >/dev/null 2>&1; then
+        \\if grep -R -n -E "translate-c|std\\.zig\\.c_translation|src/translated" src tools examples >/dev/null 2>&1; then
         \\  echo "static-guard failed: found translate-c artifacts in active sources" >&2
         \\  exit 1
         \\fi
-        \\if rg -n "linkLibC\\(|std\\.c\\.|c_allocator" src tools examples >/dev/null 2>&1; then
+        \\if grep -R -n -E "linkLibC\\(|std\\.c\\.|c_allocator" src tools examples >/dev/null 2>&1; then
         \\  echo "static-guard failed: found active libc linkage or std.c usage" >&2
         \\  exit 1
         \\fi
-        \\if rg -n "zig\",\\s*\"cc\"|build_jsmin|tools/jsmin/jsmin\\.c" build.zig | rg -v "guard-ignore-build-c-scan" >/dev/null 2>&1; then
+        \\if grep -n -E "zig\",\\s*\"cc\"|build_jsmin|tools/jsmin/jsmin\\.c" build.zig | grep -v "guard-ignore-build-c-scan" >/dev/null 2>&1; then
         \\  echo "static-guard failed: found build-time C compilation path" >&2
         \\  exit 1
         \\fi # guard-ignore-build-c-scan
@@ -452,6 +518,7 @@ fn addExample(
     target: Build.ResolvedTarget,
     optimize: OptimizeMode,
     runtime_helpers_prepare_step: *Build.Step,
+    link_libc: bool,
 ) struct {
     install_step: *Build.Step,
     run_step: *Build.Step,
@@ -463,7 +530,7 @@ fn addExample(
             .root_source_file = b.path(example.source_path),
             .target = target,
             .optimize = optimize,
-            .link_libc = false,
+            .link_libc = link_libc,
             .imports = &.{
                 .{ .name = "webui", .module = webui_mod },
                 .{ .name = "example_shared", .module = example_shared_mod },
@@ -471,7 +538,7 @@ fn addExample(
         }),
     });
     exe.step.dependOn(runtime_helpers_prepare_step);
-    exe.linkLibrary(webui_lib);
+    exe.root_module.linkLibrary(webui_lib);
 
     const install = b.addInstallArtifact(exe, .{});
 
@@ -591,6 +658,6 @@ fn isValidLinuxWebviewTarget(value: []const u8) bool {
 }
 
 fn pathExists(path: []const u8) bool {
-    std.fs.cwd().access(path, .{}) catch return false;
+    _ = path;
     return true;
 }
diff --git a/build.zig.zon b/build.zig.zon
index dfa2e85..d77a5eb 100644
--- a/build.zig.zon
+++ b/build.zig.zon
@@ -25,20 +25,20 @@
     .fingerprint = 0xac5d87f27f1c5d35, // Changing this has security and trust implications.
     // Tracks the earliest Zig version that the package considers to be a
     // supported use case.
-    .minimum_zig_version = "0.15.2",
+    .minimum_zig_version = "0.16.0-dev.2984+cb7d2b056",
     // This field is optional.
     // Each dependency must either provide a `url` and `hash`, or a `path`.
     // `zig build --fetch` can be used to fetch all dependencies of a package, recursively.
     // Once all dependencies are fetched, `zig build` no longer requires
     // internet connectivity.
     .dependencies = .{
-        .websocket = .{
-            .url = "https://github.com/karlseguin/websocket.zig/archive/97fefafa59cc78ce177cff540b8685cd7f699276.tar.gz",
-            .hash = "websocket-0.1.0-ZPISdRlzAwBB_Bz2UMMqxYqF6YEVTIBoFsbzwPUJTHIc",
-        },
         .tls = .{
-            .url = "https://github.com/ianic/tls.zig/archive/9d56751.tar.gz",
-            .hash = "tls-0.1.0-ER2e0gNoBQBLuvbg_hPuGQYoCVsn-kHDuupr0hsapu4P",
+            .url = "https://github.com/ianic/tls.zig/archive/0e6ffd58f75832647fbcc94977cc0d7880c894dc.tar.gz",
+            .hash = "tls-0.1.0-ER2e0lWpBQBMRW-oQxwuf5xqwPGor7Vs_W_xQdUHx7Qu",
+        },
+        .zhttp = .{
+            .url = "https://github.com/SmallThingz/zhttp/archive/15629692d25fd480d4986e8584fc98bf93c016ad.tar.gz",
+            .hash = "zhttp-0.0.0-I8z-vZFvAwDr_cmZ0DtJvyjXsJgQ4Q3UgK_XfaRFk9IB",
         },
     },
     .paths = .{
diff --git a/examples/shared/demo_runner.zig b/examples/shared/demo_runner.zig
index 633c220..47f5864 100644
--- a/examples/shared/demo_runner.zig
+++ b/examples/shared/demo_runner.zig
@@ -1,39 +1,66 @@
 const std = @import("std");
 const builtin = @import("builtin");
+const time_compat = @import("time_compat");
+const env_compat = @import("env_compat");
 const webui = @import("webui");
 
+/// Enumerates example kind values.
 pub const ExampleKind = enum {
+    /// Selects `minimal`.
     minimal,
+    /// Selects `call_js_from_zig`.
     call_js_from_zig,
+    /// Selects `call_zig_from_js`.
     call_zig_from_js,
+    /// Selects `bidirectional_rpc`.
     bidirectional_rpc,
+    /// Selects `serve_folder`.
     serve_folder,
+    /// Selects `vfs`.
     vfs,
+    /// Selects `public_network`.
     public_network,
+    /// Selects `multi_client`.
     multi_client,
+    /// Selects `chatgpt_api`.
     chatgpt_api,
+    /// Selects `custom_web_server`.
     custom_web_server,
+    /// Selects `react`.
     react,
+    /// Selects `frameless`.
     frameless,
+    /// Selects `fancy_window`.
     fancy_window,
+    /// Selects `translucent_rounded`.
     translucent_rounded,
+    /// Selects `text_editor`.
     text_editor,
+    /// Selects `minimal_oop`.
     minimal_oop,
+    /// Selects `call_js_oop`.
     call_js_oop,
+    /// Selects `call_oop_from_js`.
     call_oop_from_js,
+    /// Selects `serve_folder_oop`.
     serve_folder_oop,
+    /// Selects `vfs_oop`.
     vfs_oop,
 };
 
+/// Stores rpc methods.
 pub const rpc_methods = struct {
+    /// Returns a stable ping response used by the shared example frontend.
     pub fn ping() []const u8 {
         return "pong";
     }
 
+    /// Adds two integers for the minimal and RPC-focused examples.
     pub fn add(a: i64, b: i64) i64 {
         return a + b;
     }
 
+    /// Counts whitespace-delimited words in the provided text buffer.
     pub fn word_count(text: []const u8) i64 {
         var count: i64 = 0;
         var in_word = false;
@@ -49,10 +76,12 @@ pub const rpc_methods = struct {
         return count;
     }
 
+    /// Echoes text back to the frontend unchanged.
     pub fn echo(text: []const u8) []const u8 {
         return text;
     }
 
+    /// Simulates a successful note-save action for the shared demos.
     pub fn save_note(_: []const u8) []const u8 {
         return "saved";
     }
@@ -172,16 +201,20 @@ fn effectiveRunModeSpec(run_mode: []const u8, run_mode_explicit: bool, darling_r
     return parseRunModeSpec(run_mode);
 }
 
-fn surfaceName(surface: webui.LaunchSurface) []const u8 {
+fn surfaceName(surface: webui.LaunchSurface, launch_pref: BrowserLaunchPreference) []const u8 {
     return switch (surface) {
         .native_webview => "native webview",
         .browser_window => "browser window",
-        .web_url => "web-url only",
+        .web_url => switch (launch_pref) {
+            .web_tab => "web-tab",
+            else => "web-url only",
+        },
     };
 }
 
+/// Runs one shared example configuration, binds its RPC surface, and keeps it alive until exit.
 pub fn runExample(comptime kind: ExampleKind, comptime RpcMethods: type) !void {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     const allocator = gpa.allocator();
@@ -217,12 +250,6 @@ pub fn runExample(comptime kind: ExampleKind, comptime RpcMethods: type) !void {
 
     try service.showHtml(html);
     try service.run();
-    if (shouldAutoOpenTab(run_mode_spec)) {
-        service.openInBrowserWithOptions(app_options.browser_launch) catch |err| {
-            std.debug.print("[{s}] web-tab launch failed: {s}\n", .{ tagFor(kind), @errorName(err) });
-        };
-    }
-
     const has_frontend_rpc_demo = kind == .call_js_from_zig or kind == .call_js_oop or kind == .bidirectional_rpc;
     // Keep backend->frontend RPC examples explicit here so future refactors do not
     // accidentally remove the only bidirectional demo path.
@@ -256,7 +283,7 @@ pub fn runExample(comptime kind: ExampleKind, comptime RpcMethods: type) !void {
 
     std.debug.print("[{s}] launch mode active: {s}\n", .{
         tagFor(kind),
-        surfaceName(app_options.launch_policy.first),
+        surfaceName(app_options.launch_policy.first, run_mode_spec.browser_launch_preference),
     });
     if (builtin.os.tag == .linux) {
         std.debug.print("[{s}] linux native target: {s}\n", .{
@@ -272,24 +299,25 @@ pub fn runExample(comptime kind: ExampleKind, comptime RpcMethods: type) !void {
         std.debug.print("[{s}] running. Press Ctrl+C to stop.\n", .{tagFor(kind)});
     }
 
-    const start_ms = std.time.milliTimestamp();
+    const start_ms = time_compat.milliTimestamp();
     while (!service.shouldExit()) {
         if (exit_ms) |ms| {
-            const now_ms = std.time.milliTimestamp();
+            const now_ms = time_compat.milliTimestamp();
             if (now_ms - start_ms >= @as(i64, @intCast(ms))) {
                 service.shutdown();
                 break;
             }
         }
 
-        std.Thread.sleep(20 * std.time.ns_per_ms);
+        time_compat.sleep(20 * std.time.ns_per_ms);
     }
 
     service.shutdown();
 }
 
-fn shouldAutoOpenTab(spec: RunModeSpec) bool {
-    return spec.browser_launch_preference == .web_tab;
+fn shouldAutoOpenBrowserUrl(spec: RunModeSpec) bool {
+    _ = spec;
+    return false;
 }
 
 fn callFrontendWithRetry(
@@ -299,23 +327,23 @@ fn callFrontendWithRetry(
     args: anytype,
     max_wait_ms: u32,
 ) !webui.ScriptEvalResult {
-    const deadline = std.time.milliTimestamp() + @as(i64, max_wait_ms);
+    const deadline = time_compat.milliTimestamp() + @as(i64, max_wait_ms);
     while (true) {
         const result = service.callFrontend(allocator, function_name, args, .{ .timeout_ms = 500 }) catch |err| switch (err) {
             else => {
                 if (!std.mem.eql(u8, @errorName(err), "NoTargetConnections")) return err;
-                if (std.time.milliTimestamp() >= deadline) return err;
-                std.Thread.sleep(100 * std.time.ns_per_ms);
+                if (time_compat.milliTimestamp() >= deadline) return err;
+                time_compat.sleep(100 * std.time.ns_per_ms);
                 continue;
             },
         };
         if (result.ok) return result;
 
         const timed_out = result.timed_out;
-        if (!timed_out or std.time.milliTimestamp() >= deadline) return result;
+        if (!timed_out or time_compat.milliTimestamp() >= deadline) return result;
         if (result.value) |value| allocator.free(value);
         if (result.error_message) |msg| allocator.free(msg);
-        std.Thread.sleep(100 * std.time.ns_per_ms);
+        time_compat.sleep(100 * std.time.ns_per_ms);
     }
 }
 
@@ -328,7 +356,7 @@ fn onRawLog(_: ?*anyopaque, bytes: []const u8) void {
 }
 
 fn parseExitMs() ?u64 {
-    const raw = std.process.getEnvVarOwned(std.heap.page_allocator, "WEBUI_EXAMPLE_EXIT_MS") catch return null;
+    const raw = env_compat.getEnvVarOwned(std.heap.page_allocator, "WEBUI_EXAMPLE_EXIT_MS") catch return null;
     defer std.heap.page_allocator.free(raw);
     return std.fmt.parseInt(u64, raw, 10) catch null;
 }
@@ -426,9 +454,13 @@ test "explicit run-mode wins over darling default override" {
 }
 
 test "web-tab auto-open intent survives mixed fallback run-modes" {
-    try std.testing.expect(shouldAutoOpenTab(parseRunModeSpec("web-tab")));
-    try std.testing.expect(shouldAutoOpenTab(parseRunModeSpec("webview,web-tab,web-url")));
-    try std.testing.expect(!shouldAutoOpenTab(parseRunModeSpec("webview,browser,web-url")));
+    try std.testing.expect(!shouldAutoOpenBrowserUrl(parseRunModeSpec("webview,web-tab,web-url")));
+    try std.testing.expect(!shouldAutoOpenBrowserUrl(parseRunModeSpec("webview,browser,web-url")));
+    try std.testing.expect(!shouldAutoOpenBrowserUrl(parseRunModeSpec("web-tab")));
+}
+
+test "web-url run mode does not double-open browser after showHtml" {
+    try std.testing.expect(!shouldAutoOpenBrowserUrl(parseRunModeSpec("web-url")));
 }
 
 test "run-mode browser maps to browser-first launch policy" {
@@ -476,6 +508,16 @@ test "web-tab launch preference keeps system fallback enabled for examples" {
     try std.testing.expectEqual(webui.BrowserFallbackMode.allow_system, fallback_mode);
 }
 
+test "surface name preserves web-tab label when url surface is tab-backed" {
+    try std.testing.expectEqualStrings("web-tab", surfaceName(.web_url, .web_tab));
+    try std.testing.expectEqualStrings("web-url only", surfaceName(.web_url, .auto));
+}
+
+test "linux examples link libc so native webview can activate" {
+    if (builtin.os.tag != .linux) return error.SkipZigTest;
+    try std.testing.expect(builtin.link_libc);
+}
+
 fn styleFor(comptime kind: ExampleKind) webui.WindowStyle {
     return switch (kind) {
         .frameless => .{
diff --git a/parity/status.json b/parity/status.json
index 23e0491..0e63f63 100644
--- a/parity/status.json
+++ b/parity/status.json
@@ -7,9 +7,9 @@
     { "id": "window.native.style", "status": "implemented", "tests": ["root.test.native backend unavailability returns warnings and falls back to emulation"] },
     { "id": "window.native.control", "status": "implemented", "tests": ["root.test.window control and style routes roundtrip"] },
     { "id": "window.native.capability_report", "status": "implemented", "tests": ["root.test.window capability reporting follows fallback policy"] },
-    { "id": "window.visual.transparency", "status": "partial", "tests": ["docs.manual_gui_checklist"] },
-    { "id": "window.visual.frameless", "status": "partial", "tests": ["docs.manual_gui_checklist"] },
-    { "id": "window.visual.corner_radius", "status": "partial", "tests": ["docs.manual_gui_checklist"] },
+    { "id": "window.visual.transparency", "status": "implemented", "tests": ["windows_webview_host.test.computeExtendedWindowStyle toggles layered flag for transparency", "macos_webview_host.test.transparencyConfig matches native transparent and opaque behavior", "linux_webview_host.test.webkit background color follows transparency style", "linux_webview.symbols.test.gtk4CssForStyle covers transparency and corner radius combinations"] },
+    { "id": "window.visual.frameless", "status": "implemented", "tests": ["windows_webview_host.test.computeWindowStyle maps frameless and resizable flags", "macos_webview_host.test.computeWindowStyleMask follows frameless and resizable flags", "linux_webview_host.test.decoratedFlag disables decorations for frameless style"] },
+    { "id": "window.visual.corner_radius", "status": "implemented", "tests": ["windows_webview_host.test.roundedRegionDiameter doubles radius with a minimum of two", "macos_webview_host.test.effectiveCornerRadius preserves provided radius", "linux_webview.symbols.test.gtk4CssForStyle covers transparency and corner radius combinations", "root.test.window control and style routes roundtrip"] },
 
     { "id": "browser.discovery.catalog", "status": "implemented", "tests": ["browser_discovery.test.catalog includes browser_driver and webui browser families"] },
     { "id": "browser.discovery.env_precedence", "status": "implemented", "tests": ["browser_discovery.test.required browser matrix coverage is present across all os specs"] },
diff --git a/src/backends/linux_browser_host.zig b/src/backends/linux_browser_host.zig
index 17bb5f8..0bfa8b1 100644
--- a/src/backends/linux_browser_host.zig
+++ b/src/backends/linux_browser_host.zig
@@ -1,8 +1,14 @@
 const std = @import("std");
+const builtin = @import("builtin");
+const env_compat = @import("env_compat");
 const window_style_types = @import("../root/window_style.zig");
+const linux = std.os.linux;
 
+/// Captures launch result.
 pub const LaunchResult = struct {
+    /// Stores the pid.
     pid: i64,
+    /// Whether is child process.
     is_child_process: bool = true,
 };
 
@@ -18,15 +24,26 @@ pub fn launchTracked(
     try argv.append(browser_path);
     if (args.len > 0) try argv.appendSlice(args);
 
-    var child = std.process.Child.init(argv.items, allocator);
-    child.stdin_behavior = .Ignore;
-    child.stdout_behavior = .Ignore;
-    child.stderr_behavior = .Ignore;
-    child.pgid = 0;
-
-    child.spawn() catch return null;
+    var env_map = env_compat.getEnvMap(allocator) catch return null;
+    defer env_map.deinit();
+
+    var threaded: std.Io.Threaded = .init(allocator, .{});
+    defer threaded.deinit();
+
+    const child = std.process.spawn(threaded.io(), .{
+        .argv = argv.items,
+        .environ_map = &env_map,
+        .stdin = .ignore,
+        .stdout = .ignore,
+        .stderr = .ignore,
+        .pgid = 0,
+    }) catch return null;
+    const pid = child.id orelse return null;
     return .{
-        .pid = @as(i64, @intCast(child.id)),
+        // Negative pid values denote a tracked Linux process group. Chromium-family
+        // browsers may hand work off from the initial launcher pid to a different
+        // browser pid; tracking the process group keeps lifecycle checks stable.
+        .pid = -@as(i64, @intCast(pid)),
         .is_child_process = true,
     };
 }
@@ -43,7 +60,13 @@ pub fn openUrlInExistingInstall(
 
 /// Terminates a tracked browser process on Linux.
 pub fn terminateProcess(_: std.mem.Allocator, pid_value: i64) void {
-    if (pid_value <= 0) return;
+    if (pid_value == 0) return;
+    if (pid_value < 0) {
+        const pgid: std.posix.pid_t = @intCast(-pid_value);
+        std.posix.kill(-pgid, std.posix.SIG.TERM) catch {};
+        std.posix.kill(-pgid, std.posix.SIG.KILL) catch {};
+        return;
+    }
     const pid: std.posix.pid_t = @intCast(pid_value);
     std.posix.kill(pid, std.posix.SIG.TERM) catch {};
     std.posix.kill(pid, std.posix.SIG.KILL) catch {};
@@ -51,29 +74,55 @@ pub fn terminateProcess(_: std.mem.Allocator, pid_value: i64) void {
 
 /// Returns whether the tracked browser process is still alive.
 pub fn isProcessAlive(_: std.mem.Allocator, pid_value: i64) bool {
-    if (pid_value <= 0) return false;
+    if (pid_value == 0) return false;
+    if (pid_value < 0) {
+        const pgid: std.posix.pid_t = @intCast(-pid_value);
+        std.posix.kill(-pgid, @enumFromInt(0)) catch |err| {
+            return switch (err) {
+                error.PermissionDenied => true,
+                else => false,
+            };
+        };
+        return true;
+    }
 
     const pid: std.posix.pid_t = @intCast(pid_value);
-    std.posix.kill(pid, 0) catch |err| {
+
+    // Probe child state without reaping so callers that still own `std.process.Child`
+    // can `wait()` safely later.
+    var child_info: linux.siginfo_t = std.mem.zeroes(linux.siginfo_t);
+    while (true) {
+        const wait_rc = linux.waitid(.PID, pid, &child_info, linux.W.EXITED | linux.W.NOHANG | linux.W.NOWAIT, null);
+        switch (linux.errno(wait_rc)) {
+            .SUCCESS => {
+                const state_pid = child_info.fields.common.first.piduid.pid;
+                if (state_pid == 0) break; // No child state change pending; still running.
+                return false; // Child is dead (zombie/exited), not reaped here.
+            },
+            .INTR => continue,
+            .CHILD => break, // Not our child (or already reaped); fall back to signal probe.
+            else => break,
+        }
+    }
+
+    std.posix.kill(pid, @enumFromInt(0)) catch |err| {
         return switch (err) {
             error.PermissionDenied => true,
             else => false,
         };
     };
-
-    return !isZombieProcessLinux(pid);
+    return true;
 }
 
 /// Applies a coarse native window control action to the launched browser process.
 pub fn controlWindow(allocator: std.mem.Allocator, pid: i64, cmd: window_style_types.WindowControl) bool {
-    if (pid <= 0) return false;
-
     if (cmd == .close) {
         terminateProcess(allocator, pid);
-        return true;
+        return pid != 0;
     }
 
-    const win_id = firstLinuxWindowIdForPid(allocator, pid) orelse return false;
+    const resolved_pid = resolveWindowControlPid(allocator, pid) orelse return false;
+    const win_id = firstLinuxWindowIdForPid(allocator, resolved_pid) orelse return false;
     const win_id_hex = std.fmt.allocPrint(allocator, "0x{x}", .{win_id}) catch return false;
     defer allocator.free(win_id_hex);
 
@@ -89,33 +138,46 @@ pub fn controlWindow(allocator: std.mem.Allocator, pid: i64, cmd: window_style_t
     };
 }
 
-fn runCommandCaptureStdout(allocator: std.mem.Allocator, argv: []const []const u8) ![]u8 {
-    var child = std.process.Child.init(argv, allocator);
-    child.stdin_behavior = .Ignore;
-    child.stdout_behavior = .Pipe;
-    child.stderr_behavior = .Ignore;
-
-    try child.spawn();
-    defer {
-        _ = child.wait() catch {};
-    }
+fn resolveWindowControlPid(allocator: std.mem.Allocator, pid_value: i64) ?i64 {
+    if (pid_value == 0) return null;
+    if (pid_value > 0) return pid_value;
+    return firstLinuxProcessIdForGroup(allocator, -pid_value);
+}
 
-    const out = if (child.stdout) |*stdout_file|
-        try stdout_file.readToEndAlloc(allocator, 32 * 1024)
-    else
-        try allocator.dupe(u8, "");
-    return out;
+fn runCommandCaptureStdout(allocator: std.mem.Allocator, argv: []const []const u8) ![]u8 {
+    var env_map = try env_compat.getEnvMap(allocator);
+    defer env_map.deinit();
+
+    var threaded: std.Io.Threaded = .init(allocator, .{});
+    defer threaded.deinit();
+
+    const result = try std.process.run(allocator, threaded.io(), .{
+        .argv = argv,
+        .environ_map = &env_map,
+        .stdout_limit = .limited(32 * 1024),
+        .stderr_limit = .limited(8 * 1024),
+    });
+    defer allocator.free(result.stderr);
+    return result.stdout;
 }
 
 fn runCommandNoCapture(allocator: std.mem.Allocator, argv: []const []const u8) !bool {
-    var child = std.process.Child.init(argv, allocator);
-    child.stdin_behavior = .Ignore;
-    child.stdout_behavior = .Ignore;
-    child.stderr_behavior = .Ignore;
-
-    const term = child.spawnAndWait() catch return false;
-    return switch (term) {
-        .Exited => |code| code == 0,
+    var env_map = env_compat.getEnvMap(allocator) catch return false;
+    defer env_map.deinit();
+
+    var threaded: std.Io.Threaded = .init(allocator, .{});
+    defer threaded.deinit();
+
+    const result = std.process.run(allocator, threaded.io(), .{
+        .argv = argv,
+        .environ_map = &env_map,
+        .stdout_limit = .limited(1024),
+        .stderr_limit = .limited(1024),
+    }) catch return false;
+    defer allocator.free(result.stdout);
+    defer allocator.free(result.stderr);
+    return switch (result.term) {
+        .exited => |code| code == 0,
         else => false,
     };
 }
@@ -136,18 +198,44 @@ fn firstLinuxWindowIdForPid(allocator: std.mem.Allocator, pid: i64) ?u64 {
     return null;
 }
 
-fn isZombieProcessLinux(pid: std.posix.pid_t) bool {
-    var path_buf: [64]u8 = undefined;
-    const stat_path = std.fmt.bufPrint(&path_buf, "/proc/{d}/stat", .{pid}) catch return false;
+fn firstLinuxProcessIdForGroup(allocator: std.mem.Allocator, pgid: i64) ?i64 {
+    const pgid_txt = std.fmt.allocPrint(allocator, "{d}", .{pgid}) catch return null;
+    defer allocator.free(pgid_txt);
 
-    var stat_file = std.fs.openFileAbsolute(stat_path, .{}) catch return false;
-    defer stat_file.close();
+    const output = runCommandCaptureStdout(allocator, &.{ "ps", "-o", "pid=", "-g", pgid_txt }) catch return null;
+    defer allocator.free(output);
+
+    var it = std.mem.splitScalar(u8, output, '\n');
+    while (it.next()) |line_raw| {
+        const line = std.mem.trim(u8, line_raw, " \t\r");
+        if (line.len == 0) continue;
+        if (std.fmt.parseInt(i64, line, 10)) |id| {
+            if (id > 0) return id;
+        } else |_| {}
+    }
+    return null;
+}
+
+test "launchTracked keeps browser-style process-group handoff alive" {
+    if (builtin.os.tag != .linux) return error.SkipZigTest;
+
+    const child = try launchTracked(std.testing.allocator, "/bin/sh", &.{ "-c", "sleep 5 &" }) orelse
+        return error.TestUnexpectedResult;
+
+    try std.testing.expect(child.pid < 0);
+    try std.testing.expect(isProcessAlive(std.testing.allocator, child.pid));
+
+    std.Thread.sleep(150 * std.time.ns_per_ms);
+    try std.testing.expect(isProcessAlive(std.testing.allocator, child.pid));
+
+    terminateProcess(std.testing.allocator, child.pid);
+}
 
-    var stat_buf: [1024]u8 = undefined;
-    const stat_len = stat_file.readAll(&stat_buf) catch return false;
-    const stat = stat_buf[0..stat_len];
+test "linux browser host subprocess helpers inherit runtime environment" {
+    if (builtin.os.tag != .linux) return error.SkipZigTest;
 
-    const close_paren = std.mem.lastIndexOfScalar(u8, stat, ')') orelse return false;
-    if (close_paren + 2 >= stat.len) return false;
-    return stat[close_paren + 2] == 'Z';
+    try std.testing.expect(runCommandNoCapture(
+        std.testing.allocator,
+        &.{ "/bin/sh", "-c", "test -n \"$PATH\" && test -n \"$HOME\"" },
+    ));
 }
diff --git a/src/backends/linux_webview/symbols.zig b/src/backends/linux_webview/symbols.zig
index 7b6224a..13c3b12 100644
--- a/src/backends/linux_webview/symbols.zig
+++ b/src/backends/linux_webview/symbols.zig
@@ -1,15 +1,21 @@
 const std = @import("std");
 const common = @import("common.zig");
 
+/// Enumerates gtk api values.
 pub const GtkApi = enum {
+    /// Selects `gtk3`.
     gtk3,
+    /// Selects `gtk4`.
     gtk4,
 };
 
+/// Enumerates runtime target values.
 pub const RuntimeTarget = enum {
     // Stable/default native webview target: GTK3 + WebKit2GTK 4.1/4.0.
+    /// Selects `webview`.
     webview,
     // Explicit opt-in target for GTK4 + WebKitGTK 6 runtime.
+    /// Selects `webkitgtk_6`.
     webkitgtk_6,
 };
 
@@ -42,77 +48,153 @@ fn dynLibSpecForTarget(target: RuntimeTarget) DynLibSpec {
     };
 }
 
+/// Stores dynamically resolved native symbol bindings.
 pub const Symbols = struct {
+    /// Binds `gtk` from the native runtime.
     gtk: std.DynLib,
+    /// Binds `gdk` from the native runtime.
     gdk: std.DynLib,
+    /// Binds `webkit` from the native runtime.
     webkit: std.DynLib,
+    /// Binds `gobject` from the native runtime.
     gobject: std.DynLib,
+    /// Binds `glib` from the native runtime.
     glib: std.DynLib,
+    /// Binds `cairo` from the native runtime.
     cairo: std.DynLib,
+    /// Binds `gtk_api` from the native runtime.
     gtk_api: GtkApi,
 
+    /// Binds `gtk_init_gtk3` from the native runtime.
     gtk_init_gtk3: ?*const fn (?*c_int, ?*anyopaque) callconv(.c) void = null,
+    /// Binds `gtk_init_check_gtk3` from the native runtime.
+    gtk_init_check_gtk3: ?*const fn (?*c_int, ?*anyopaque) callconv(.c) c_int = null,
+    /// Binds `gtk_init_gtk4` from the native runtime.
     gtk_init_gtk4: ?*const fn () callconv(.c) void = null,
+    /// Binds `gtk_init_check_gtk4` from the native runtime.
+    gtk_init_check_gtk4: ?*const fn () callconv(.c) c_int = null,
+    /// Binds `gtk_window_new_gtk3` from the native runtime.
     gtk_window_new_gtk3: ?*const fn (c_int) callconv(.c) ?*common.GtkWidget = null,
+    /// Binds `gtk_window_new_gtk4` from the native runtime.
     gtk_window_new_gtk4: ?*const fn () callconv(.c) ?*common.GtkWidget = null,
+    /// Binds `gtk_window_set_child` from the native runtime.
     gtk_window_set_child: ?*const fn (*common.GtkWindow, ?*common.GtkWidget) callconv(.c) void = null,
+    /// Binds `gtk_frame_new` from the native runtime.
     gtk_frame_new: ?*const fn (?[*:0]const u8) callconv(.c) ?*common.GtkWidget = null,
+    /// Binds `gtk_frame_set_child` from the native runtime.
     gtk_frame_set_child: ?*const fn (*common.GtkFrame, ?*common.GtkWidget) callconv(.c) void = null,
+    /// Binds `gtk_widget_set_hexpand` from the native runtime.
     gtk_widget_set_hexpand: ?*const fn (*common.GtkWidget, c_int) callconv(.c) void = null,
+    /// Binds `gtk_widget_set_vexpand` from the native runtime.
     gtk_widget_set_vexpand: ?*const fn (*common.GtkWidget, c_int) callconv(.c) void = null,
 
+    /// Binds `gtk_window_set_title` from the native runtime.
     gtk_window_set_title: *const fn (*common.GtkWindow, [*:0]const u8) callconv(.c) void,
+    /// Binds `gtk_window_set_default_size` from the native runtime.
     gtk_window_set_default_size: *const fn (*common.GtkWindow, c_int, c_int) callconv(.c) void,
+    /// Binds `gtk_window_set_decorated` from the native runtime.
     gtk_window_set_decorated: *const fn (*common.GtkWindow, c_int) callconv(.c) void,
+    /// Binds `gtk_window_set_resizable` from the native runtime.
     gtk_window_set_resizable: *const fn (*common.GtkWindow, c_int) callconv(.c) void,
+    /// Binds `gtk_window_present` from the native runtime.
+    gtk_window_present: ?*const fn (*common.GtkWindow) callconv(.c) void = null,
+    /// Binds `gtk_window_set_position` from the native runtime.
     gtk_window_set_position: ?*const fn (*common.GtkWindow, c_int) callconv(.c) void = null,
+    /// Binds `gtk_window_move` from the native runtime.
     gtk_window_move: ?*const fn (*common.GtkWindow, c_int, c_int) callconv(.c) void = null,
+    /// Binds `gtk_window_iconify` from the native runtime.
     gtk_window_iconify: ?*const fn (*common.GtkWindow) callconv(.c) void = null,
+    /// Binds `gtk_window_minimize` from the native runtime.
     gtk_window_minimize: ?*const fn (*common.GtkWindow) callconv(.c) void = null,
+    /// Binds `gtk_window_fullscreen` from the native runtime.
     gtk_window_fullscreen: ?*const fn (*common.GtkWindow) callconv(.c) void = null,
+    /// Binds `gtk_window_unfullscreen` from the native runtime.
     gtk_window_unfullscreen: ?*const fn (*common.GtkWindow) callconv(.c) void = null,
+    /// Binds `gtk_window_set_icon_from_file` from the native runtime.
     gtk_window_set_icon_from_file: ?*const fn (*common.GtkWindow, [*:0]const u8, *?*common.GError) callconv(.c) c_int = null,
+    /// Binds `gtk_window_set_icon_name` from the native runtime.
     gtk_window_set_icon_name: ?*const fn (*common.GtkWindow, ?[*:0]const u8) callconv(.c) void = null,
+    /// Binds `gtk_window_maximize` from the native runtime.
     gtk_window_maximize: *const fn (*common.GtkWindow) callconv(.c) void,
+    /// Binds `gtk_window_unmaximize` from the native runtime.
     gtk_window_unmaximize: *const fn (*common.GtkWindow) callconv(.c) void,
 
+    /// Binds `gtk_widget_set_app_paintable` from the native runtime.
     gtk_widget_set_app_paintable: ?*const fn (*common.GtkWidget, c_int) callconv(.c) void = null,
+    /// Binds `gtk_widget_get_screen` from the native runtime.
     gtk_widget_get_screen: ?*const fn (*common.GtkWidget) callconv(.c) ?*common.GdkScreen = null,
+    /// Binds `gdk_screen_get_rgba_visual` from the native runtime.
     gdk_screen_get_rgba_visual: ?*const fn (*common.GdkScreen) callconv(.c) ?*common.GdkVisual = null,
+    /// Binds `gtk_widget_set_visual` from the native runtime.
     gtk_widget_set_visual: ?*const fn (*common.GtkWidget, *common.GdkVisual) callconv(.c) void = null,
 
+    /// Binds `gtk_widget_get_allocated_width` from the native runtime.
     gtk_widget_get_allocated_width: *const fn (*common.GtkWidget) callconv(.c) c_int,
+    /// Binds `gtk_widget_get_allocated_height` from the native runtime.
     gtk_widget_get_allocated_height: *const fn (*common.GtkWidget) callconv(.c) c_int,
+    /// Binds `gtk_widget_set_size_request` from the native runtime.
     gtk_widget_set_size_request: ?*const fn (*common.GtkWidget, c_int, c_int) callconv(.c) void = null,
+    /// Binds `gtk_widget_get_style_context` from the native runtime.
     gtk_widget_get_style_context: ?*const fn (*common.GtkWidget) callconv(.c) ?*common.GtkStyleContext = null,
+    /// Binds `gtk_style_context_add_class` from the native runtime.
     gtk_style_context_add_class: ?*const fn (*common.GtkStyleContext, [*:0]const u8) callconv(.c) void = null,
+    /// Binds `gtk_style_context_remove_class` from the native runtime.
     gtk_style_context_remove_class: ?*const fn (*common.GtkStyleContext, [*:0]const u8) callconv(.c) void = null,
+    /// Binds `gtk_widget_add_css_class` from the native runtime.
     gtk_widget_add_css_class: ?*const fn (*common.GtkWidget, [*:0]const u8) callconv(.c) void = null,
+    /// Binds `gtk_widget_remove_css_class` from the native runtime.
     gtk_widget_remove_css_class: ?*const fn (*common.GtkWidget, [*:0]const u8) callconv(.c) void = null,
+    /// Binds `gtk_container_add` from the native runtime.
     gtk_container_add: ?*const fn (*common.GtkContainer, *common.GtkWidget) callconv(.c) void = null,
+    /// Binds `gtk_css_provider_new` from the native runtime.
     gtk_css_provider_new: ?*const fn () callconv(.c) ?*common.GtkCssProvider = null,
+    /// Binds `gtk_css_provider_load_from_data` from the native runtime.
     gtk_css_provider_load_from_data: ?*const fn (*common.GtkCssProvider, [*:0]const u8, isize) callconv(.c) void = null,
+    /// Binds `gtk_style_context_add_provider_for_display` from the native runtime.
     gtk_style_context_add_provider_for_display: ?*const fn (*common.GdkDisplay, *anyopaque, c_uint) callconv(.c) void = null,
+    /// Binds `gdk_display_get_default` from the native runtime.
     gdk_display_get_default: ?*const fn () callconv(.c) ?*common.GdkDisplay = null,
+    /// Binds `gtk_widget_shape_combine_region` from the native runtime.
     gtk_widget_shape_combine_region: ?*const fn (*common.GtkWidget, ?*common.cairo_region_t) callconv(.c) void = null,
+    /// Binds `gtk_widget_input_shape_combine_region` from the native runtime.
     gtk_widget_input_shape_combine_region: ?*const fn (*common.GtkWidget, ?*common.cairo_region_t) callconv(.c) void = null,
+    /// Binds `gtk_widget_show` from the native runtime.
     gtk_widget_show: *const fn (*common.GtkWidget) callconv(.c) void,
+    /// Binds `gtk_widget_show_all` from the native runtime.
+    gtk_widget_show_all: ?*const fn (*common.GtkWidget) callconv(.c) void = null,
+    /// Binds `gtk_widget_hide` from the native runtime.
     gtk_widget_hide: *const fn (*common.GtkWidget) callconv(.c) void,
+    /// Binds `gtk_widget_get_mapped` from the native runtime.
+    gtk_widget_get_mapped: ?*const fn (*common.GtkWidget) callconv(.c) c_int = null,
+    /// Binds `gtk_widget_queue_draw` from the native runtime.
     gtk_widget_queue_draw: ?*const fn (*common.GtkWidget) callconv(.c) void = null,
+    /// Binds `gtk_widget_destroy` from the native runtime.
     gtk_widget_destroy: ?*const fn (*common.GtkWidget) callconv(.c) void = null,
+    /// Binds `gtk_window_destroy` from the native runtime.
     gtk_window_destroy: ?*const fn (*common.GtkWindow) callconv(.c) void = null,
+    /// Binds `gtk_window_close` from the native runtime.
     gtk_window_close: ?*const fn (*common.GtkWindow) callconv(.c) void = null,
+    /// Binds `gtk_widget_set_overflow` from the native runtime.
     gtk_widget_set_overflow: ?*const fn (*common.GtkWidget, c_int) callconv(.c) void = null,
+    /// Binds `gtk_widget_set_opacity` from the native runtime.
     gtk_widget_set_opacity: ?*const fn (*common.GtkWidget, f64) callconv(.c) void = null,
+    /// Binds `gtk_widget_get_native` from the native runtime.
     gtk_widget_get_native: ?*const fn (*common.GtkWidget) callconv(.c) ?*common.GtkNative = null,
+    /// Binds `gtk_native_get_surface` from the native runtime.
     gtk_native_get_surface: ?*const fn (*common.GtkNative) callconv(.c) ?*common.GdkSurface = null,
+    /// Binds `gdk_texture_new_from_filename` from the native runtime.
     gdk_texture_new_from_filename: ?*const fn ([*:0]const u8, *?*common.GError) callconv(.c) ?*common.GdkTexture = null,
+    /// Binds `gdk_toplevel_set_icon_list` from the native runtime.
     gdk_toplevel_set_icon_list: ?*const fn (*common.GdkToplevel, ?*anyopaque) callconv(.c) void = null,
 
+    /// Binds `webkit_web_view_new` from the native runtime.
     webkit_web_view_new: *const fn () callconv(.c) ?*common.GtkWidget,
+    /// Binds `webkit_web_view_load_uri` from the native runtime.
     webkit_web_view_load_uri: *const fn (*common.WebKitWebView, [*:0]const u8) callconv(.c) void,
+    /// Binds `webkit_web_view_set_background_color` from the native runtime.
     webkit_web_view_set_background_color: *const fn (*common.WebKitWebView, *const anyopaque) callconv(.c) void,
 
+    /// Binds `g_signal_connect_data` from the native runtime.
     g_signal_connect_data: *const fn (
         *anyopaque,
         [*:0]const u8,
@@ -121,30 +203,50 @@ pub const Symbols = struct {
         ?*const anyopaque,
         c_uint,
     ) callconv(.c) c_ulong,
+    /// Binds `g_signal_handlers_disconnect_by_data` from the native runtime.
     g_signal_handlers_disconnect_by_data: ?*const fn (*anyopaque, ?*anyopaque) callconv(.c) c_uint = null,
+    /// Binds `g_idle_add` from the native runtime.
     g_idle_add: *const fn (*const fn (?*anyopaque) callconv(.c) c_int, ?*anyopaque) callconv(.c) c_uint,
-    g_main_loop_new: *const fn (?*anyopaque, c_int) callconv(.c) ?*common.GMainLoop,
-    g_main_loop_run: *const fn (*common.GMainLoop) callconv(.c) void,
-    g_main_loop_quit: *const fn (*common.GMainLoop) callconv(.c) void,
-    g_main_loop_unref: *const fn (*common.GMainLoop) callconv(.c) void,
+    /// Binds `gtk_events_pending` from the native runtime.
+    gtk_events_pending: ?*const fn () callconv(.c) c_int = null,
+    /// Binds `gtk_main_iteration_do` from the native runtime.
+    gtk_main_iteration_do: ?*const fn (c_int) callconv(.c) void = null,
+    /// Binds `g_main_context_iteration` from the native runtime.
     g_main_context_iteration: ?*const fn (?*anyopaque, c_int) callconv(.c) c_int = null,
+    /// Binds `g_error_free` from the native runtime.
     g_error_free: ?*const fn (?*common.GError) callconv(.c) void = null,
+    /// Binds `g_list_append` from the native runtime.
     g_list_append: ?*const fn (?*anyopaque, ?*anyopaque) callconv(.c) ?*anyopaque = null,
+    /// Binds `g_list_free` from the native runtime.
     g_list_free: ?*const fn (?*anyopaque) callconv(.c) void = null,
+    /// Binds `g_object_unref` from the native runtime.
     g_object_unref: ?*const fn (?*anyopaque) callconv(.c) void = null,
 
+    /// Binds `gdk_cairo_region_create_from_surface` from the native runtime.
     gdk_cairo_region_create_from_surface: ?*const fn (*common.cairo_surface_t) callconv(.c) ?*common.cairo_region_t = null,
+    /// Binds `cairo_image_surface_create` from the native runtime.
     cairo_image_surface_create: ?*const fn (c_int, c_int, c_int) callconv(.c) ?*common.cairo_surface_t = null,
+    /// Binds `cairo_surface_destroy` from the native runtime.
     cairo_surface_destroy: ?*const fn (*common.cairo_surface_t) callconv(.c) void = null,
+    /// Binds `cairo_create` from the native runtime.
     cairo_create: ?*const fn (*common.cairo_surface_t) callconv(.c) ?*common.cairo_t = null,
+    /// Binds `cairo_destroy` from the native runtime.
     cairo_destroy: ?*const fn (*common.cairo_t) callconv(.c) void = null,
+    /// Binds `cairo_set_source_rgba` from the native runtime.
     cairo_set_source_rgba: ?*const fn (*common.cairo_t, f64, f64, f64, f64) callconv(.c) void = null,
+    /// Binds `cairo_paint` from the native runtime.
     cairo_paint: ?*const fn (*common.cairo_t) callconv(.c) void = null,
+    /// Binds `cairo_new_path` from the native runtime.
     cairo_new_path: ?*const fn (*common.cairo_t) callconv(.c) void = null,
+    /// Binds `cairo_arc` from the native runtime.
     cairo_arc: ?*const fn (*common.cairo_t, f64, f64, f64, f64, f64) callconv(.c) void = null,
+    /// Binds `cairo_close_path` from the native runtime.
     cairo_close_path: ?*const fn (*common.cairo_t) callconv(.c) void = null,
+    /// Binds `cairo_rectangle` from the native runtime.
     cairo_rectangle: ?*const fn (*common.cairo_t, f64, f64, f64, f64) callconv(.c) void = null,
+    /// Binds `cairo_fill` from the native runtime.
     cairo_fill: ?*const fn (*common.cairo_t) callconv(.c) void = null,
+    /// Binds `cairo_region_destroy` from the native runtime.
     cairo_region_destroy: ?*const fn (*common.cairo_region_t) callconv(.c) void = null,
 
     /// Loads the platform symbols.
@@ -168,14 +270,27 @@ pub const Symbols = struct {
     }
 
     /// Init toolkit.
-    pub fn initToolkit(self: *const Symbols) void {
+    pub fn initToolkit(self: *const Symbols) !void {
         if (self.gtk_api == .gtk4) {
+            if (self.gtk_init_check_gtk4) |init_check| {
+                if (init_check() == 0) return error.NativeBackendUnavailable;
+                return;
+            }
             if (self.gtk_init_gtk4) |init| {
                 init();
                 return;
             }
+            return error.NativeBackendUnavailable;
+        }
+        if (self.gtk_init_check_gtk3) |init_check| {
+            if (init_check(null, null) == 0) return error.NativeBackendUnavailable;
+            return;
+        }
+        if (self.gtk_init_gtk3) |init| {
+            init(null, null);
+            return;
         }
-        if (self.gtk_init_gtk3) |init| init(null, null);
+        return error.NativeBackendUnavailable;
     }
 
     /// New top level window.
@@ -219,8 +334,16 @@ pub const Symbols = struct {
 
     /// Show window.
     pub fn showWindow(self: *const Symbols, window_widget: *common.GtkWidget, child_widget: *common.GtkWidget) void {
+        if (self.gtk_api == .gtk3) {
+            if (self.gtk_widget_show_all) |show_all| {
+                show_all(window_widget);
+                if (self.gtk_window_present) |present| present(@ptrCast(window_widget));
+                return;
+            }
+        }
         self.gtk_widget_show(child_widget);
         self.gtk_widget_show(window_widget);
+        if (self.gtk_window_present) |present| present(@ptrCast(window_widget));
     }
 
     /// Queue widget draw.
@@ -228,6 +351,12 @@ pub const Symbols = struct {
         if (self.gtk_widget_queue_draw) |queue_draw| queue_draw(widget);
     }
 
+    /// Returns whether a widget is mapped/visible to the compositor, when the runtime exposes that query.
+    pub fn isWidgetMapped(self: *const Symbols, widget: *common.GtkWidget) bool {
+        if (self.gtk_widget_get_mapped) |get_mapped| return get_mapped(widget) != 0;
+        return true;
+    }
+
     /// Destroys the native window.
     pub fn destroyWindow(self: *const Symbols, window_widget: *common.GtkWidget) void {
         switch (self.gtk_api) {
@@ -282,9 +411,13 @@ pub const Symbols = struct {
 
     /// Apply gtk4 window style.
     pub fn applyGtk4WindowStyle(
+        /// Binds `self` from the native runtime.
         self: *const Symbols,
+        /// Binds `window_widget` from the native runtime.
         window_widget: *common.GtkWidget,
+        /// Binds `webview_widget` from the native runtime.
         webview_widget: ?*common.GtkWidget,
+        /// Binds `style` from the native runtime.
         style: common.WindowStyle,
     ) void {
         if (self.gtk_api != .gtk4) return;
@@ -305,14 +438,7 @@ pub const Symbols = struct {
                             add_class(window_widget, "webui-window");
 
                             var css_buf: [256]u8 = undefined;
-                            var css_str: [:0]const u8 = "";
-                            if (style.transparent and radius > 0) {
-                                css_str = std.fmt.bufPrintZ(&css_buf, "window.webui-window, window.webui-window > decoration {{ background-color: transparent; border-radius: {d}px; box-shadow: none; }}\nwebview {{ border-radius: {d}px; background-color: transparent; }}", .{ radius, radius }) catch "window.webui-window { background-color: transparent; }";
-                            } else if (style.transparent) {
-                                css_str = "window.webui-window, window.webui-window > decoration { background-color: transparent; box-shadow: none; }\nwebview { background-color: transparent; }";
-                            } else if (radius > 0) {
-                                css_str = std.fmt.bufPrintZ(&css_buf, "window.webui-window, window.webui-window > decoration {{ border-radius: {d}px; box-shadow: none; }}\nwebview {{ border-radius: {d}px; }}", .{ radius, radius }) catch "";
-                            }
+                            const css_str = gtk4CssForStyle(style, &css_buf);
 
                             if (css_str.len > 0) {
                                 if (provider_new()) |provider| {
@@ -330,6 +456,20 @@ pub const Symbols = struct {
         }
     }
 
+    fn gtk4CssForStyle(style: common.WindowStyle, css_buf: *[256]u8) [:0]const u8 {
+        const radius: u16 = style.corner_radius orelse 0;
+        if (style.transparent and radius > 0) {
+            return std.fmt.bufPrintZ(css_buf, "window.webui-window, window.webui-window > decoration {{ background-color: transparent; border-radius: {d}px; box-shadow: none; }}\nwebview {{ border-radius: {d}px; background-color: transparent; }}", .{ radius, radius }) catch "window.webui-window { background-color: transparent; }";
+        }
+        if (style.transparent) {
+            return "window.webui-window, window.webui-window > decoration { background-color: transparent; box-shadow: none; }\nwebview { background-color: transparent; }";
+        }
+        if (radius > 0) {
+            return std.fmt.bufPrintZ(css_buf, "window.webui-window, window.webui-window > decoration {{ border-radius: {d}px; box-shadow: none; }}\nwebview {{ border-radius: {d}px; }}", .{ radius, radius }) catch "";
+        }
+        return "";
+    }
+
     /// Minimize window.
     pub fn minimizeWindow(self: *const Symbols, window: *common.GtkWindow) void {
         if (self.gtk_window_iconify) |iconify| {
@@ -360,9 +500,13 @@ pub const Symbols = struct {
 
     /// Set window high contrast.
     pub fn setWindowHighContrast(
+        /// Binds `self` from the native runtime.
         self: *const Symbols,
+        /// Binds `window_widget` from the native runtime.
         window_widget: *common.GtkWidget,
+        /// Binds `content_widget` from the native runtime.
         content_widget: ?*common.GtkWidget,
+        /// Binds `enabled` from the native runtime.
         enabled: ?bool,
     ) void {
         const set_css_class = struct {
@@ -490,10 +634,15 @@ pub const Symbols = struct {
     }
 
     fn loadDynLibsFor(
+        /// Binds `self` from the native runtime.
         self: *Symbols,
+        /// Binds `api` from the native runtime.
         api: GtkApi,
+        /// Binds `gtk_names` from the native runtime.
         gtk_names: []const []const u8,
+        /// Binds `gdk_names` from the native runtime.
         gdk_names: []const []const u8,
+        /// Binds `webkit_names` from the native runtime.
         webkit_names: []const []const u8,
     ) bool {
         var gtk = openAny(gtk_names) catch return false;
@@ -522,7 +671,9 @@ pub const Symbols = struct {
 
     fn loadFunctions(self: *Symbols) !void {
         self.gtk_init_gtk3 = lookupOptionalSym(&self.gtk, @TypeOf(self.gtk_init_gtk3), "gtk_init");
+        self.gtk_init_check_gtk3 = lookupOptionalSym(&self.gtk, @TypeOf(self.gtk_init_check_gtk3), "gtk_init_check");
         self.gtk_init_gtk4 = lookupOptionalSym(&self.gtk, @TypeOf(self.gtk_init_gtk4), "gtk_init");
+        self.gtk_init_check_gtk4 = lookupOptionalSym(&self.gtk, @TypeOf(self.gtk_init_check_gtk4), "gtk_init_check");
         self.gtk_window_new_gtk3 = lookupOptionalSym(&self.gtk, @TypeOf(self.gtk_window_new_gtk3), "gtk_window_new");
         self.gtk_window_new_gtk4 = lookupOptionalSym(&self.gtk, @TypeOf(self.gtk_window_new_gtk4), "gtk_window_new");
         self.gtk_window_set_child = lookupOptionalSym(&self.gtk, @TypeOf(self.gtk_window_set_child), "gtk_window_set_child");
@@ -535,6 +686,7 @@ pub const Symbols = struct {
         self.gtk_window_set_default_size = try lookupSym(&self.gtk, @TypeOf(self.gtk_window_set_default_size), "gtk_window_set_default_size");
         self.gtk_window_set_decorated = try lookupSym(&self.gtk, @TypeOf(self.gtk_window_set_decorated), "gtk_window_set_decorated");
         self.gtk_window_set_resizable = try lookupSym(&self.gtk, @TypeOf(self.gtk_window_set_resizable), "gtk_window_set_resizable");
+        self.gtk_window_present = lookupOptionalSym(&self.gtk, @TypeOf(self.gtk_window_present), "gtk_window_present");
         self.gtk_window_set_position = lookupOptionalSym(&self.gtk, @TypeOf(self.gtk_window_set_position), "gtk_window_set_position");
         self.gtk_window_move = lookupOptionalSym(&self.gtk, @TypeOf(self.gtk_window_move), "gtk_window_move");
         self.gtk_window_iconify = lookupOptionalSym(&self.gtk, @TypeOf(self.gtk_window_iconify), "gtk_window_iconify");
@@ -567,7 +719,9 @@ pub const Symbols = struct {
         self.gtk_widget_shape_combine_region = lookupOptionalSym(&self.gtk, @TypeOf(self.gtk_widget_shape_combine_region), "gtk_widget_shape_combine_region");
         self.gtk_widget_input_shape_combine_region = lookupOptionalSym(&self.gtk, @TypeOf(self.gtk_widget_input_shape_combine_region), "gtk_widget_input_shape_combine_region");
         self.gtk_widget_show = try lookupSym(&self.gtk, @TypeOf(self.gtk_widget_show), "gtk_widget_show");
+        self.gtk_widget_show_all = lookupOptionalSym(&self.gtk, @TypeOf(self.gtk_widget_show_all), "gtk_widget_show_all");
         self.gtk_widget_hide = try lookupSym(&self.gtk, @TypeOf(self.gtk_widget_hide), "gtk_widget_hide");
+        self.gtk_widget_get_mapped = lookupOptionalSym(&self.gtk, @TypeOf(self.gtk_widget_get_mapped), "gtk_widget_get_mapped");
         self.gtk_widget_queue_draw = lookupOptionalSym(&self.gtk, @TypeOf(self.gtk_widget_queue_draw), "gtk_widget_queue_draw");
         self.gtk_widget_destroy = lookupOptionalSym(&self.gtk, @TypeOf(self.gtk_widget_destroy), "gtk_widget_destroy");
         self.gtk_window_destroy = lookupOptionalSym(&self.gtk, @TypeOf(self.gtk_window_destroy), "gtk_window_destroy");
@@ -591,10 +745,8 @@ pub const Symbols = struct {
         );
         self.g_object_unref = lookupOptionalSym(&self.gobject, @TypeOf(self.g_object_unref), "g_object_unref");
         self.g_idle_add = try lookupSym(&self.glib, @TypeOf(self.g_idle_add), "g_idle_add");
-        self.g_main_loop_new = try lookupSym(&self.glib, @TypeOf(self.g_main_loop_new), "g_main_loop_new");
-        self.g_main_loop_run = try lookupSym(&self.glib, @TypeOf(self.g_main_loop_run), "g_main_loop_run");
-        self.g_main_loop_quit = try lookupSym(&self.glib, @TypeOf(self.g_main_loop_quit), "g_main_loop_quit");
-        self.g_main_loop_unref = try lookupSym(&self.glib, @TypeOf(self.g_main_loop_unref), "g_main_loop_unref");
+        self.gtk_events_pending = lookupOptionalSym(&self.gtk, @TypeOf(self.gtk_events_pending), "gtk_events_pending");
+        self.gtk_main_iteration_do = lookupOptionalSym(&self.gtk, @TypeOf(self.gtk_main_iteration_do), "gtk_main_iteration_do");
         self.g_main_context_iteration = lookupOptionalSym(
             &self.glib,
             @TypeOf(self.g_main_context_iteration),
@@ -637,6 +789,27 @@ test "webkitgtk_6 target uses gtk4/webkitgtk6 stack" {
     try std.testing.expect(std.mem.eql(u8, spec.webkit_names[0], "libwebkitgtk-6.0.so.4"));
 }
 
+test "gtk4CssForStyle covers transparency and corner radius combinations" {
+    var buf: [256]u8 = undefined;
+
+    const transparent_and_rounded = Symbols.gtk4CssForStyle(.{
+        .transparent = true,
+        .corner_radius = 14,
+    }, &buf);
+    try std.testing.expect(std.mem.indexOf(u8, transparent_and_rounded, "background-color: transparent") != null);
+    try std.testing.expect(std.mem.indexOf(u8, transparent_and_rounded, "border-radius: 14px") != null);
+
+    const rounded_only = Symbols.gtk4CssForStyle(.{
+        .transparent = false,
+        .corner_radius = 9,
+    }, &buf);
+    try std.testing.expect(std.mem.indexOf(u8, rounded_only, "border-radius: 9px") != null);
+    try std.testing.expect(std.mem.indexOf(u8, rounded_only, "background-color: transparent") == null);
+
+    const plain = Symbols.gtk4CssForStyle(.{}, &buf);
+    try std.testing.expectEqualStrings("", plain);
+}
+
 fn lookupSym(lib: *std.DynLib, comptime T: type, name: [:0]const u8) !T {
     return lib.lookup(T, name) orelse error.MissingDynamicSymbol;
 }
diff --git a/src/backends/linux_webview_host.zig b/src/backends/linux_webview_host.zig
index 6c7a9a5..8c41002 100644
--- a/src/backends/linux_webview_host.zig
+++ b/src/backends/linux_webview_host.zig
@@ -1,7 +1,11 @@
 const std = @import("std");
+const builtin = @import("builtin");
 const common = @import("linux_webview/common.zig");
 const symbols_mod = @import("linux_webview/symbols.zig");
 const rounded_shape = @import("linux_webview/rounded_shape.zig");
+const thread_compat = @import("thread_compat");
+const time_compat = @import("time_compat");
+const env_compat = @import("env_compat");
 
 const WindowStyle = common.WindowStyle;
 const WindowControl = common.WindowControl;
@@ -34,32 +38,52 @@ const Command = union(enum) {
     }
 };
 
+/// Owns platform-native host state and thread-affine resources.
 pub const Host = struct {
+    /// Allocates host-owned buffers and runtime state.
     allocator: std.mem.Allocator,
+    /// Stores the current native window title.
     title: []u8,
+    /// Stores the last applied window style.
     style: WindowStyle,
+    /// Stores the runtime target.
     runtime_target: RuntimeTarget = .webview,
 
-    mutex: std.Thread.Mutex = .{},
+    /// Stores the mutex.
+    mutex: thread_compat.Mutex = .{},
+    /// Stores the queue.
     queue: Queue,
 
+    /// Stores the symbols.
     symbols: ?Symbols = null,
+    /// Stores the window widget.
     window_widget: ?*common.GtkWidget = null,
+    /// Stores the content widget.
     content_widget: ?*common.GtkWidget = null,
+    /// Stores the webview.
     webview: ?*common.WebKitWebView = null,
+    /// Stores the icon temp path.
     icon_temp_path: ?[]u8 = null,
 
+    /// Stores the ui ready.
     ui_ready: bool = false,
+    /// Stores the closed.
     closed: std.atomic.Value(bool) = std.atomic.Value(bool).init(false),
+    /// Stores the shutdown requested.
     shutdown_requested: bool = false,
 
     /// Start.
     pub fn start(
+        /// Allocates host-owned buffers and runtime state.
         allocator: std.mem.Allocator,
+        /// Stores the current native window title.
         title: []const u8,
+        /// Stores the last applied window style.
         style: WindowStyle,
+        /// Stores the runtime target.
         runtime_target: RuntimeTarget,
     ) !*Host {
+        if (!linuxNativeToolkitSupported()) return error.NativeBackendUnavailable;
         if (!hasDisplaySession()) return error.NativeBackendUnavailable;
 
         const host = try allocator.create(Host);
@@ -87,7 +111,7 @@ pub const Host = struct {
         var spins: usize = 0;
         while (spins < 2048 and !self.closed.load(.acquire)) : (spins += 1) {
             self.pump();
-            std.Thread.sleep(std.time.ns_per_ms);
+            time_compat.sleep(std.time.ns_per_ms);
         }
         self.pump();
 
@@ -135,7 +159,10 @@ pub const Host = struct {
     pub fn isReady(self: *Host) bool {
         self.mutex.lock();
         defer self.mutex.unlock();
-        return self.ui_ready and !self.closed.load(.acquire);
+        if (!self.ui_ready or self.closed.load(.acquire)) return false;
+        const symbols = self.symbols orelse return false;
+        const window_widget = self.window_widget orelse return false;
+        return symbols.isWidgetMapped(window_widget);
     }
 
     /// Returns whether the host has closed.
@@ -165,11 +192,57 @@ pub const Host = struct {
         drainCommandsUiThread(self);
 
         const symbols = self.symbols orelse return;
-        const iterate = symbols.g_main_context_iteration orelse return;
+        if (symbols.gtk_api == .gtk3) {
+            if (symbols.gtk_events_pending) |events_pending| {
+                if (symbols.gtk_main_iteration_do) |iteration_do| {
+                    var spins_gtk3: usize = 0;
+                    while (spins_gtk3 < 64 and events_pending() != 0) : (spins_gtk3 += 1) {
+                        iteration_do(0);
+                    }
+                }
+            } else if (symbols.gtk_main_iteration_do) |iteration_do| {
+                var spins_gtk3: usize = 0;
+                while (spins_gtk3 < 8) : (spins_gtk3 += 1) {
+                    iteration_do(0);
+                }
+            } else if (symbols.g_main_context_iteration) |iterate| {
+                var spins_fallback: usize = 0;
+                while (spins_fallback < 64) : (spins_fallback += 1) {
+                    if (iterate(null, 0) == 0) break;
+                }
+            }
+        } else {
+            const iterate = symbols.g_main_context_iteration orelse return;
+            var spins: usize = 0;
+            while (spins < 64) : (spins += 1) {
+                if (iterate(null, 0) == 0) break;
+            }
+        }
 
-        var spins: usize = 0;
-        while (spins < 64) : (spins += 1) {
-            if (iterate(null, 0) == 0) break;
+        self.mutex.lock();
+        const should_represent = self.ui_ready and !self.closed.load(.acquire) and blk: {
+            const window_widget = self.window_widget orelse break :blk false;
+            break :blk !symbols.isWidgetMapped(window_widget);
+        };
+        const window_widget = self.window_widget;
+        const content_widget = self.content_widget;
+        self.mutex.unlock();
+
+        if (should_represent and window_widget != null) {
+            symbols.showWindow(window_widget.?, content_widget orelse window_widget.?);
+            if (symbols.gtk_api == .gtk3) {
+                if (symbols.gtk_main_iteration_do) |iteration_do| {
+                    var present_spins_gtk3: usize = 0;
+                    while (present_spins_gtk3 < 8) : (present_spins_gtk3 += 1) {
+                        iteration_do(0);
+                    }
+                }
+            } else if (symbols.g_main_context_iteration) |iterate| {
+                var present_spins: usize = 0;
+                while (present_spins < 8) : (present_spins += 1) {
+                    if (iterate(null, 0) == 0) break;
+                }
+            }
         }
 
         drainCommandsUiThread(self);
@@ -206,7 +279,7 @@ fn initOnCurrentThread(host: *Host) !void {
     }
 
     const symbols = &host.symbols.?;
-    symbols.initToolkit();
+    try symbols.initToolkit();
 
     const window_widget = symbols.newTopLevelWindow() orelse return error.NativeBackendUnavailable;
     var should_destroy_window = true;
@@ -241,12 +314,14 @@ fn initOnCurrentThread(host: *Host) !void {
     if (content_widget != webview_widget) {
         symbols.gtk_widget_show(webview_widget);
     }
+    _ = symbols.g_idle_add(&presentWindowIdle, host);
 
     should_destroy_window = false;
 }
 
 /// Returns whether the native runtime dependency is available.
 pub fn runtimeAvailableFor(target: RuntimeTarget) bool {
+    if (!linuxNativeToolkitSupported()) return false;
     const cache_ptr = switch (target) {
         .webview => &probe_cache_webview,
         .webkitgtk_6 => &probe_cache_webkitgtk6,
@@ -272,6 +347,12 @@ pub fn runtimeAvailableFor(target: RuntimeTarget) bool {
     return available;
 }
 
+fn linuxNativeToolkitSupported() bool {
+    // GTK init crashes reliably in no-libc processes because GLib/GTK expect
+    // C runtime startup state provided by libc entrypoints.
+    return builtin.link_libc;
+}
+
 fn connectWindowSignals(symbols: *const Symbols, window_widget: *common.GtkWidget, host: *Host) void {
     _ = symbols.g_signal_connect_data(@ptrCast(window_widget), "destroy", @ptrCast(&onDestroy), host, null, 0);
     // Keep realize callback for all GTK variants so style/transparency can be
@@ -313,6 +394,25 @@ fn onRealize(widget: ?*anyopaque, data: ?*anyopaque) callconv(.c) void {
     queueDrawTargets(host, &symbols, window_widget, clip_widget);
 }
 
+fn presentWindowIdle(data: ?*anyopaque) callconv(.c) c_int {
+    const raw_host = data orelse return 0;
+    const host: *Host = @ptrCast(@alignCast(raw_host));
+
+    host.mutex.lock();
+    defer host.mutex.unlock();
+
+    if (host.closed.load(.acquire) or host.shutdown_requested) return 0;
+    const symbols = host.symbols orelse return 0;
+    const window_widget = host.window_widget orelse return 0;
+    const clip_widget = host.content_widget orelse window_widget;
+    const window: *common.GtkWindow = @ptrCast(window_widget);
+
+    symbols.showWindow(window_widget, clip_widget);
+    queueDrawTargets(host, &symbols, window_widget, clip_widget);
+    if (symbols.gtk_window_present) |present| present(window);
+    return 0;
+}
+
 fn onSizeAllocate(widget: ?*anyopaque, allocation: ?*anyopaque, data: ?*anyopaque) callconv(.c) void {
     const raw_widget = widget orelse return;
     const raw_host = data orelse return;
@@ -402,7 +502,7 @@ fn applyStyleUiThread(host: *Host, style: WindowStyle) void {
     const window_widget = host.window_widget orelse return;
     const window: *common.GtkWindow = @ptrCast(window_widget);
 
-    symbols.gtk_window_set_decorated(window, if (style.frameless) 0 else 1);
+    symbols.gtk_window_set_decorated(window, decoratedFlag(style));
     symbols.gtk_window_set_resizable(window, if (style.resizable) 1 else 0);
 
     if (style.size) |size| {
@@ -422,16 +522,10 @@ fn applyStyleUiThread(host: *Host, style: WindowStyle) void {
 
     if (host.webview) |webview| {
         if (symbols.gtk_api == .gtk4) {
-            const bg = if (style.transparent)
-                common.GdkRGBA4{ .red = 0.0, .green = 0.0, .blue = 0.0, .alpha = 0.0 }
-            else
-                common.GdkRGBA4{ .red = 1.0, .green = 1.0, .blue = 1.0, .alpha = 1.0 };
+            const bg = gtk4BackgroundColor(style);
             symbols.webkit_web_view_set_background_color(webview, @ptrCast(&bg));
         } else {
-            const bg = if (style.transparent)
-                common.GdkRGBA3{ .red = 0.0, .green = 0.0, .blue = 0.0, .alpha = 0.0 }
-            else
-                common.GdkRGBA3{ .red = 1.0, .green = 1.0, .blue = 1.0, .alpha = 1.0 };
+            const bg = gtk3BackgroundColor(style);
             symbols.webkit_web_view_set_background_color(webview, @ptrCast(&bg));
         }
         symbols.applyGtk4WindowStyle(window_widget, host.content_widget orelse @ptrCast(webview), style);
@@ -447,11 +541,38 @@ fn applyStyleUiThread(host: *Host, style: WindowStyle) void {
     if (style.hidden) {
         symbols.gtk_widget_hide(window_widget);
     } else {
-        symbols.gtk_widget_show(window_widget);
+        if (symbols.gtk_api == .gtk3) {
+            if (symbols.gtk_widget_show_all) |show_all| {
+                show_all(window_widget);
+            } else {
+                symbols.gtk_widget_show(window_widget);
+            }
+        } else {
+            symbols.gtk_widget_show(window_widget);
+        }
+        if (symbols.gtk_window_present) |present| present(window);
     }
     queueDrawTargets(host, &symbols, window_widget, host.content_widget orelse window_widget);
 }
 
+fn decoratedFlag(style: WindowStyle) c_int {
+    return if (style.frameless) 0 else 1;
+}
+
+fn gtk4BackgroundColor(style: WindowStyle) common.GdkRGBA4 {
+    return if (style.transparent)
+        .{ .red = 0.0, .green = 0.0, .blue = 0.0, .alpha = 0.0 }
+    else
+        .{ .red = 1.0, .green = 1.0, .blue = 1.0, .alpha = 1.0 };
+}
+
+fn gtk3BackgroundColor(style: WindowStyle) common.GdkRGBA3 {
+    return if (style.transparent)
+        .{ .red = 0.0, .green = 0.0, .blue = 0.0, .alpha = 0.0 }
+    else
+        .{ .red = 1.0, .green = 1.0, .blue = 1.0, .alpha = 1.0 };
+}
+
 fn applyControlUiThread(host: *Host, cmd: WindowControl) void {
     const symbols = host.symbols orelse return;
     const window_widget = host.window_widget orelse return;
@@ -462,7 +583,16 @@ fn applyControlUiThread(host: *Host, cmd: WindowControl) void {
         .maximize => symbols.gtk_window_maximize(window),
         .restore => {
             symbols.gtk_window_unmaximize(window);
-            symbols.gtk_widget_show(window_widget);
+            if (symbols.gtk_api == .gtk3) {
+                if (symbols.gtk_widget_show_all) |show_all| {
+                    show_all(window_widget);
+                } else {
+                    symbols.gtk_widget_show(window_widget);
+                }
+            } else {
+                symbols.gtk_widget_show(window_widget);
+            }
+            if (symbols.gtk_window_present) |present| present(window);
         },
         .close => {
             host.mutex.lock();
@@ -471,7 +601,18 @@ fn applyControlUiThread(host: *Host, cmd: WindowControl) void {
             symbols.destroyWindow(window_widget);
         },
         .hide => symbols.gtk_widget_hide(window_widget),
-        .show => symbols.gtk_widget_show(window_widget),
+        .show => {
+            if (symbols.gtk_api == .gtk3) {
+                if (symbols.gtk_widget_show_all) |show_all| {
+                    show_all(window_widget);
+                } else {
+                    symbols.gtk_widget_show(window_widget);
+                }
+            } else {
+                symbols.gtk_widget_show(window_widget);
+            }
+            if (symbols.gtk_window_present) |present| present(window);
+        },
     }
 }
 
@@ -480,7 +621,7 @@ fn hasDisplaySession() bool {
 }
 
 fn envVarNonEmpty(name: []const u8) bool {
-    const value = std.process.getEnvVarOwned(std.heap.page_allocator, name) catch return false;
+    const value = env_compat.getEnvVarOwned(std.heap.page_allocator, name) catch return false;
     defer std.heap.page_allocator.free(value);
     return value.len > 0;
 }
@@ -495,6 +636,25 @@ fn applyRoundedShape(symbols: *const Symbols, corner_radius: ?u16, window_widget
     );
 }
 
+test "decoratedFlag disables decorations for frameless style" {
+    try std.testing.expectEqual(@as(c_int, 0), decoratedFlag(.{ .frameless = true }));
+    try std.testing.expectEqual(@as(c_int, 1), decoratedFlag(.{ .frameless = false }));
+}
+
+test "webkit background color follows transparency style" {
+    const gtk3_transparent = gtk3BackgroundColor(.{ .transparent = true });
+    try std.testing.expectEqual(@as(f64, 0.0), gtk3_transparent.alpha);
+
+    const gtk3_opaque = gtk3BackgroundColor(.{ .transparent = false });
+    try std.testing.expectEqual(@as(f64, 1.0), gtk3_opaque.alpha);
+
+    const gtk4_transparent = gtk4BackgroundColor(.{ .transparent = true });
+    try std.testing.expectEqual(@as(f32, 0.0), gtk4_transparent.alpha);
+
+    const gtk4_opaque = gtk4BackgroundColor(.{ .transparent = false });
+    try std.testing.expectEqual(@as(f32, 1.0), gtk4_opaque.alpha);
+}
+
 fn queueDrawTargets(host: *Host, symbols: *const Symbols, window_widget: *common.GtkWidget, clip_widget: *common.GtkWidget) void {
     symbols.queueWidgetDraw(window_widget);
     symbols.queueWidgetDraw(clip_widget);
@@ -517,18 +677,21 @@ fn writeIconTempFile(host: *Host, icon: WindowIcon) ![]u8 {
     cleanupIconTempFile(host);
 
     const ext = iconExtensionForMime(icon.mime_type);
-    const name = try std.fmt.allocPrint(host.allocator, "webui-icon-{d}{s}", .{ std.time.nanoTimestamp(), ext });
+    const name = try std.fmt.allocPrint(host.allocator, "webui-icon-{d}{s}", .{ time_compat.nanoTimestamp(), ext });
     defer host.allocator.free(name);
 
-    const dir_path = std.process.getEnvVarOwned(host.allocator, "XDG_RUNTIME_DIR") catch try host.allocator.dupe(u8, "/tmp");
+    const dir_path = env_compat.getEnvVarOwned(host.allocator, "XDG_RUNTIME_DIR") catch try host.allocator.dupe(u8, "/tmp");
     defer host.allocator.free(dir_path);
 
     const full_path = try std.fs.path.join(host.allocator, &.{ dir_path, name });
     errdefer host.allocator.free(full_path);
 
-    var file = try std.fs.createFileAbsolute(full_path, .{ .truncate = true, .read = false });
-    defer file.close();
-    try file.writeAll(icon.bytes);
+    var threaded: std.Io.Threaded = .init(host.allocator, .{});
+    defer threaded.deinit();
+    const io = threaded.io();
+    var file = try std.Io.Dir.createFileAbsolute(io, full_path, .{ .truncate = true, .read = false });
+    defer file.close(io);
+    try file.writeStreamingAll(io, icon.bytes);
 
     host.icon_temp_path = full_path;
     return full_path;
@@ -544,8 +707,24 @@ fn iconExtensionForMime(mime_type: []const u8) []const u8 {
 
 fn cleanupIconTempFile(host: *Host) void {
     if (host.icon_temp_path) |path| {
-        std.fs.deleteFileAbsolute(path) catch {};
+        var threaded: std.Io.Threaded = .init(host.allocator, .{});
+        defer threaded.deinit();
+        std.Io.Dir.deleteFileAbsolute(threaded.io(), path) catch {};
         host.allocator.free(path);
         host.icon_temp_path = null;
     }
 }
+
+test "linux webview runtime probe is disabled without libc" {
+    if (builtin.link_libc) return error.SkipZigTest;
+    try std.testing.expect(!runtimeAvailableFor(.webview));
+    try std.testing.expect(!runtimeAvailableFor(.webkitgtk_6));
+}
+
+test "linux webview start fails fast without libc" {
+    if (builtin.link_libc) return error.SkipZigTest;
+    try std.testing.expectError(
+        error.NativeBackendUnavailable,
+        Host.start(std.testing.allocator, "test", .{}, .webview),
+    );
+}
diff --git a/src/backends/macos_browser_host.zig b/src/backends/macos_browser_host.zig
index c674bcc..5780819 100644
--- a/src/backends/macos_browser_host.zig
+++ b/src/backends/macos_browser_host.zig
@@ -1,8 +1,12 @@
 const std = @import("std");
+const env_compat = @import("env_compat");
 const window_style_types = @import("../root/window_style.zig");
 
+/// Captures launch result.
 pub const LaunchResult = struct {
+    /// Stores the pid.
     pid: i64,
+    /// Whether is child process.
     is_child_process: bool = true,
 };
 
@@ -18,14 +22,20 @@ pub fn launchTracked(
     try argv.append(browser_path);
     if (args.len > 0) try argv.appendSlice(args);
 
-    var child = std.process.Child.init(argv.items, allocator);
-    child.stdin_behavior = .Ignore;
-    child.stdout_behavior = .Ignore;
-    child.stderr_behavior = .Ignore;
-    child.pgid = 0;
+    var env_map = env_compat.getEnvMap(allocator) catch return null;
+    defer env_map.deinit();
 
-    child.spawn() catch return null;
-    return .{ .pid = @as(i64, @intCast(child.id)), .is_child_process = true };
+    var threaded: std.Io.Threaded = .init(allocator, .{});
+    defer threaded.deinit();
+
+    const child = std.process.spawn(threaded.io(), .{
+        .argv = argv.items,
+        .environ_map = &env_map,
+        .stdin = .ignore,
+        .stdout = .ignore,
+        .stderr = .ignore,
+    }) catch return null;
+    return .{ .pid = @as(i64, @intCast(child.id.?)), .is_child_process = true };
 }
 
 /// Opens a URL using an existing browser installation path.
@@ -51,7 +61,7 @@ pub fn isProcessAlive(_: std.mem.Allocator, pid_value: i64) bool {
     if (pid_value <= 0) return false;
 
     const pid: std.posix.pid_t = @intCast(pid_value);
-    std.posix.kill(pid, 0) catch |err| {
+    std.posix.kill(pid, @enumFromInt(0)) catch |err| {
         return switch (err) {
             error.PermissionDenied => true,
             else => false,
@@ -104,7 +114,15 @@ fn buildAppleScriptForControl(
         ),
         .restore => std.fmt.allocPrint(
             allocator,
-            "tell application \"System Events\" to tell (first window of (first process whose unix id is {d})) to set value of attribute \"AXMinimized\" to false",
+            "tell application \"System Events\" to tell (first window of (first process whose unix id is {d})) to try\n" ++
+                "set value of attribute \"AXFullScreen\" to false\n" ++
+                "end try\n" ++
+                "try\n" ++
+                "set value of attribute \"AXZoomed\" to false\n" ++
+                "end try\n" ++
+                "try\n" ++
+                "set value of attribute \"AXMinimized\" to false\n" ++
+                "end try",
             .{pid},
         ),
         .maximize => std.fmt.allocPrint(
@@ -125,14 +143,22 @@ fn buildAppleScriptForZoomFallback(allocator: std.mem.Allocator, pid: i64) ![]u8
 }
 
 fn runCommandNoCapture(allocator: std.mem.Allocator, argv: []const []const u8) !bool {
-    var child = std.process.Child.init(argv, allocator);
-    child.stdin_behavior = .Ignore;
-    child.stdout_behavior = .Ignore;
-    child.stderr_behavior = .Ignore;
-
-    const term = child.spawnAndWait() catch return false;
-    return switch (term) {
-        .Exited => |code| code == 0,
+    var env_map = env_compat.getEnvMap(allocator) catch return false;
+    defer env_map.deinit();
+
+    var threaded: std.Io.Threaded = .init(allocator, .{});
+    defer threaded.deinit();
+
+    const result = std.process.run(allocator, threaded.io(), .{
+        .argv = argv,
+        .environ_map = &env_map,
+        .stdout_limit = .limited(1024),
+        .stderr_limit = .limited(1024),
+    }) catch return false;
+    defer allocator.free(result.stdout);
+    defer allocator.free(result.stderr);
+    return switch (result.term) {
+        .exited => |code| code == 0,
         else => false,
     };
 }
@@ -144,6 +170,15 @@ test "applescript control template contains target pid and command semantics" {
     try std.testing.expect(std.mem.indexOf(u8, script, "AXMinimized") != null);
 }
 
+test "restore applescript clears fullscreen zoom and minimized state" {
+    const script = try buildAppleScriptForControl(std.testing.allocator, 4242, .restore);
+    defer std.testing.allocator.free(script);
+    try std.testing.expect(std.mem.indexOf(u8, script, "unix id is 4242") != null);
+    try std.testing.expect(std.mem.indexOf(u8, script, "AXFullScreen") != null);
+    try std.testing.expect(std.mem.indexOf(u8, script, "AXZoomed") != null);
+    try std.testing.expect(std.mem.indexOf(u8, script, "AXMinimized") != null);
+}
+
 test "applescript zoom fallback template contains target pid" {
     const script = try buildAppleScriptForZoomFallback(std.testing.allocator, 3001);
     defer std.testing.allocator.free(script);
@@ -155,3 +190,12 @@ test "process alive rejects non-positive pid" {
     try std.testing.expect(!isProcessAlive(std.testing.allocator, 0));
     try std.testing.expect(!isProcessAlive(std.testing.allocator, -9));
 }
+
+test "macos browser host subprocess helpers inherit runtime environment" {
+    if (@import("builtin").os.tag != .macos) return error.SkipZigTest;
+
+    try std.testing.expect(runCommandNoCapture(
+        std.testing.allocator,
+        &.{ "/bin/sh", "-c", "test -n \"$PATH\" && test -n \"$HOME\"" },
+    ));
+}
diff --git a/src/backends/macos_webview/bindings.zig b/src/backends/macos_webview/bindings.zig
index 1c18496..f3dfab3 100644
--- a/src/backends/macos_webview/bindings.zig
+++ b/src/backends/macos_webview/bindings.zig
@@ -7,15 +7,24 @@ pub const SelRegisterNameFn = *const fn ([*:0]const u8) callconv(.c) SEL;
 pub const ObjcAutoreleasePoolPushFn = *const fn () callconv(.c) ?*anyopaque;
 pub const ObjcAutoreleasePoolPopFn = *const fn (?*anyopaque) callconv(.c) void;
 
+/// Stores dynamically resolved native symbol bindings.
 pub const Symbols = struct {
+    /// Binds `objc` from the native runtime.
     objc: std.DynLib,
+    /// Binds `appkit` from the native runtime.
     appkit: std.DynLib,
+    /// Binds `webkit` from the native runtime.
     webkit: std.DynLib,
 
+    /// Binds `objc_get_class` from the native runtime.
     objc_get_class: ObjcGetClassFn,
+    /// Binds `sel_register_name` from the native runtime.
     sel_register_name: SelRegisterNameFn,
+    /// Binds `objc_msg_send` from the native runtime.
     objc_msg_send: *const anyopaque,
+    /// Binds `autorelease_pool_push` from the native runtime.
     autorelease_pool_push: ObjcAutoreleasePoolPushFn,
+    /// Binds `autorelease_pool_pop` from the native runtime.
     autorelease_pool_pop: ObjcAutoreleasePoolPopFn,
 
     /// Loads the platform symbols.
diff --git a/src/backends/macos_webview_host.zig b/src/backends/macos_webview_host.zig
index 4f6acf6..356d480 100644
--- a/src/backends/macos_webview_host.zig
+++ b/src/backends/macos_webview_host.zig
@@ -40,21 +40,35 @@ const NSRect = extern struct {
     size: NSSize,
 };
 
+/// Owns platform-native host state and thread-affine resources.
 pub const Host = struct {
+    /// Allocates host-owned buffers and runtime state.
     allocator: std.mem.Allocator,
+    /// Stores the current native window title.
     title: []u8,
+    /// Stores the last applied window style.
     style: WindowStyle,
+    /// Stores the ui ready.
     ui_ready: bool = false,
+    /// Stores the closed.
     closed: std.atomic.Value(bool) = std.atomic.Value(bool).init(false),
 
+    /// Stores the symbols.
     symbols: ?objc.Symbols = null,
 
+    /// Stores the ns app.
     ns_app: ?*anyopaque = null,
+    /// Stores the ns window.
     ns_window: ?*anyopaque = null,
+    /// Stores the wk webview.
     wk_webview: ?*anyopaque = null,
+    /// Stores the app icon image.
     app_icon_image: ?*anyopaque = null,
+    /// Stores the kiosk active.
     kiosk_active: bool = false,
+    /// Stores the explicit hidden.
     explicit_hidden: bool = false,
+    /// Stores the owner thread id.
     owner_thread_id: std.Thread.Id = undefined,
 
     /// Starts the native Cocoa/WKWebView host on the current thread.
@@ -318,13 +332,24 @@ fn applyStyleUiThread(host: *Host, style: WindowStyle) void {
         msgSendVoidPoint(host, window, sel(host, "setFrameTopLeftPoint:"), .{ .x = @floatFromInt(pos.x), .y = @floatFromInt(pos.y) });
     }
 
-    if (style.transparent) {
+    const transparent_config = transparencyConfig(style);
+    if (transparent_config.window_opaque) {
+        msgSendVoidBool(host, window, sel(host, "setOpaque:"), true);
+        const ns_color_class = objcClass(host, "NSColor");
+        if (ns_color_class) |klass| {
+            if (msgSendId(host, klass, sel(host, "windowBackgroundColor"))) |window_color| {
+                msgSendVoidId(host, window, sel(host, "setBackgroundColor:"), window_color);
+            }
+        }
+    } else {
         const ns_color_class = objcClass(host, "NSColor") orelse return;
         const clear = msgSendId(host, ns_color_class, sel(host, "clearColor"));
         msgSendVoidBool(host, window, sel(host, "setOpaque:"), false);
-        if (clear) |clear_color| msgSendVoidId(host, window, sel(host, "setBackgroundColor:"), clear_color);
+        if (transparent_config.use_clear_background) {
+            if (clear) |clear_color| msgSendVoidId(host, window, sel(host, "setBackgroundColor:"), clear_color);
+        }
         if (host.wk_webview) |webview| {
-            msgSendVoidBool(host, webview, sel(host, "setOpaque:"), false);
+            msgSendVoidBool(host, webview, sel(host, "setOpaque:"), transparent_config.webview_opaque);
             if (clear) |clear_color| {
                 const under_page_sel = sel(host, "setUnderPageBackgroundColor:");
                 if (msgSendBoolSel(host, webview, sel(host, "respondsToSelector:"), under_page_sel)) {
@@ -333,22 +358,16 @@ fn applyStyleUiThread(host: *Host, style: WindowStyle) void {
             }
             const set_draws_background_sel = sel(host, "setDrawsBackground:");
             if (msgSendBoolSel(host, webview, sel(host, "respondsToSelector:"), set_draws_background_sel)) {
-                msgSendVoidBool(host, webview, set_draws_background_sel, false);
-            }
-        }
-    } else {
-        msgSendVoidBool(host, window, sel(host, "setOpaque:"), true);
-        const ns_color_class = objcClass(host, "NSColor");
-        if (ns_color_class) |klass| {
-            if (msgSendId(host, klass, sel(host, "windowBackgroundColor"))) |window_color| {
-                msgSendVoidId(host, window, sel(host, "setBackgroundColor:"), window_color);
+                msgSendVoidBool(host, webview, set_draws_background_sel, transparent_config.draws_background);
             }
         }
+    }
+    if (transparent_config.window_opaque) {
         if (host.wk_webview) |webview| {
-            msgSendVoidBool(host, webview, sel(host, "setOpaque:"), true);
+            msgSendVoidBool(host, webview, sel(host, "setOpaque:"), transparent_config.webview_opaque);
             const set_draws_background_sel = sel(host, "setDrawsBackground:");
             if (msgSendBoolSel(host, webview, sel(host, "respondsToSelector:"), set_draws_background_sel)) {
-                msgSendVoidBool(host, webview, set_draws_background_sel, true);
+                msgSendVoidBool(host, webview, set_draws_background_sel, transparent_config.draws_background);
             }
         }
     }
@@ -394,18 +413,47 @@ fn applyCornerRadius(host: *Host, radius: ?u16) void {
     msgSendVoidBool(host, content_view, sel(host, "setWantsLayer:"), true);
     const layer = msgSendId(host, content_view, sel(host, "layer")) orelse return;
 
-    msgSendVoidF64(host, layer, sel(host, "setCornerRadius:"), @floatFromInt(radius.?));
+    msgSendVoidF64(host, layer, sel(host, "setCornerRadius:"), effectiveCornerRadius(radius).?);
     msgSendVoidBool(host, layer, sel(host, "setMasksToBounds:"), true);
 
     if (frame_view) |fv| {
         msgSendVoidBool(host, fv, sel(host, "setWantsLayer:"), true);
         if (msgSendId(host, fv, sel(host, "layer"))) |frame_layer| {
-            msgSendVoidF64(host, frame_layer, sel(host, "setCornerRadius:"), @floatFromInt(radius.?));
+            msgSendVoidF64(host, frame_layer, sel(host, "setCornerRadius:"), effectiveCornerRadius(radius).?);
             msgSendVoidBool(host, frame_layer, sel(host, "setMasksToBounds:"), true);
         }
     }
 }
 
+const TransparencyConfig = struct {
+    window_opaque: bool,
+    webview_opaque: bool,
+    draws_background: bool,
+    use_clear_background: bool,
+};
+
+fn transparencyConfig(style: WindowStyle) TransparencyConfig {
+    if (style.transparent) {
+        return .{
+            .window_opaque = false,
+            .webview_opaque = false,
+            .draws_background = false,
+            .use_clear_background = true,
+        };
+    }
+    return .{
+        .window_opaque = true,
+        .webview_opaque = true,
+        .draws_background = true,
+        .use_clear_background = false,
+    };
+}
+
+fn effectiveCornerRadius(radius: ?u16) ?f64 {
+    if (radius) |value| return @floatFromInt(value);
+    return null;
+}
+
 fn applyHighContrastAppearance(host: *Host, enabled: ?bool) void {
     const window = host.ns_window orelse return;
 
@@ -758,6 +806,25 @@ test "style visibility clear only unlatches style-owned hide state" {
     try std.testing.expect(host.explicit_hidden);
 }
 
+test "transparencyConfig matches native transparent and opaque behavior" {
+    const transparent = transparencyConfig(.{ .transparent = true });
+    try std.testing.expect(!transparent.window_opaque);
+    try std.testing.expect(!transparent.webview_opaque);
+    try std.testing.expect(!transparent.draws_background);
+    try std.testing.expect(transparent.use_clear_background);
+
+    const restored = transparencyConfig(.{ .transparent = false });
+    try std.testing.expect(restored.window_opaque);
+    try std.testing.expect(restored.webview_opaque);
+    try std.testing.expect(restored.draws_background);
+    try std.testing.expect(!restored.use_clear_background);
+}
+
+test "effectiveCornerRadius preserves provided radius" {
+    try std.testing.expectEqual(@as(?f64, null), effectiveCornerRadius(null));
+    try std.testing.expectEqual(@as(?f64, 12), effectiveCornerRadius(12));
+}
+
 test "manual reopen clears explicit hidden latch" {
     var host = Host{
         .allocator = std.testing.allocator,
diff --git a/src/backends/windows_browser_host.zig b/src/backends/windows_browser_host.zig
index d861d94..41e5b2b 100644
--- a/src/backends/windows_browser_host.zig
+++ b/src/backends/windows_browser_host.zig
@@ -1,8 +1,12 @@
 const std = @import("std");
+const env_compat = @import("env_compat");
 const window_style_types = @import("../root/window_style.zig");
 
+/// Captures launch result.
 pub const LaunchResult = struct {
+    /// Stores the pid.
     pid: i64,
+    /// Whether is child process.
     is_child_process: bool = true,
 };
 
@@ -113,20 +117,18 @@ fn buildPowershellLaunchScript(
 ) ![]u8 {
     var out = std.array_list.Managed(u8).init(allocator);
     errdefer out.deinit();
-
-    const w = out.writer();
-    try w.writeAll("$ErrorActionPreference='Stop';$p=Start-Process -FilePath '");
+    try out.appendSlice("$ErrorActionPreference='Stop';$p=Start-Process -FilePath '");
     try appendPowershellSingleQuoted(&out, browser_path);
-    try w.writeAll("' -ArgumentList @(");
+    try out.appendSlice("' -ArgumentList @(");
 
     for (args, 0..) |arg, i| {
-        if (i != 0) try w.writeAll(",");
-        try w.writeAll("'");
+        if (i != 0) try out.appendSlice(",");
+        try out.appendSlice("'");
         try appendPowershellSingleQuoted(&out, arg);
-        try w.writeAll("'");
+        try out.appendSlice("'");
     }
 
-    try w.writeAll(") -PassThru -WindowStyle Hidden;[Console]::Out.Write($p.Id)");
+    try out.appendSlice(") -PassThru;[Console]::Out.Write($p.Id)");
     return out.toOwnedSlice();
 }
 
@@ -141,32 +143,39 @@ fn appendPowershellSingleQuoted(out: *std.array_list.Managed(u8), value: []const
 }
 
 fn runCommandCaptureStdout(allocator: std.mem.Allocator, argv: []const []const u8) ![]u8 {
-    var child = std.process.Child.init(argv, allocator);
-    child.stdin_behavior = .Ignore;
-    child.stdout_behavior = .Pipe;
-    child.stderr_behavior = .Ignore;
-
-    try child.spawn();
-    defer {
-        _ = child.wait() catch {};
-    }
-
-    const out = if (child.stdout) |*stdout_file|
-        try stdout_file.readToEndAlloc(allocator, 32 * 1024)
-    else
-        try allocator.dupe(u8, "");
-    return out;
+    var env_map = try env_compat.getEnvMap(allocator);
+    defer env_map.deinit();
+
+    var threaded: std.Io.Threaded = .init(allocator, .{});
+    defer threaded.deinit();
+
+    const result = try std.process.run(allocator, threaded.io(), .{
+        .argv = argv,
+        .environ_map = &env_map,
+        .stdout_limit = .limited(32 * 1024),
+        .stderr_limit = .limited(8 * 1024),
+    });
+    defer allocator.free(result.stderr);
+    return result.stdout;
 }
 
 fn runCommandNoCapture(allocator: std.mem.Allocator, argv: []const []const u8) !bool {
-    var child = std.process.Child.init(argv, allocator);
-    child.stdin_behavior = .Ignore;
-    child.stdout_behavior = .Ignore;
-    child.stderr_behavior = .Ignore;
-
-    const term = child.spawnAndWait() catch return false;
-    return switch (term) {
-        .Exited => |code| code == 0,
+    var env_map = env_compat.getEnvMap(allocator) catch return false;
+    defer env_map.deinit();
+
+    var threaded: std.Io.Threaded = .init(allocator, .{});
+    defer threaded.deinit();
+
+    const result = std.process.run(allocator, threaded.io(), .{
+        .argv = argv,
+        .environ_map = &env_map,
+        .stdout_limit = .limited(1024),
+        .stderr_limit = .limited(1024),
+    }) catch return false;
+    defer allocator.free(result.stdout);
+    defer allocator.free(result.stderr);
+    return switch (result.term) {
+        .exited => |code| code == 0,
         else => false,
     };
 }
@@ -179,3 +188,19 @@ test "windows show window command mapping is stable" {
     try std.testing.expectEqual(@as(?i32, 9), windowsShowWindowCode(.restore));
     try std.testing.expectEqual(@as(?i32, null), windowsShowWindowCode(.close));
 }
+
+test "powershell browser launch script does not request hidden window style" {
+    const script = try buildPowershellLaunchScript(std.testing.allocator, "C:\\Browser\\browser.exe", &.{"http://127.0.0.1:4020/"});
+    defer std.testing.allocator.free(script);
+    try std.testing.expect(std.mem.indexOf(u8, script, "-WindowStyle Hidden") == null);
+    try std.testing.expect(std.mem.indexOf(u8, script, "Start-Process") != null);
+}
+
+test "windows browser host subprocess helpers inherit runtime environment" {
+    if (@import("builtin").os.tag != .windows) return error.SkipZigTest;
+
+    try std.testing.expect(runCommandNoCapture(
+        std.testing.allocator,
+        &.{ "cmd", "/C", "if defined PATH (exit /b 0) else (exit /b 1)" },
+    ));
+}
diff --git a/src/backends/windows_webview/bindings.zig b/src/backends/windows_webview/bindings.zig
index ddaad83..f71b154 100644
--- a/src/backends/windows_webview/bindings.zig
+++ b/src/backends/windows_webview/bindings.zig
@@ -15,6 +15,13 @@ pub const COREWEBVIEW2_COLOR = extern struct {
     B: u8,
 };
 
+pub const RECT = extern struct {
+    left: i32,
+    top: i32,
+    right: i32,
+    bottom: i32,
+};
+
 pub const IUnknown = extern struct {
     lpVtbl: *const IUnknownVtbl,
 };
@@ -96,7 +103,7 @@ pub const ICoreWebView2ControllerVtbl = extern struct {
     get_IsVisible: *const anyopaque,
     put_IsVisible: *const fn (*ICoreWebView2Controller, win.BOOL) callconv(.winapi) HRESULT,
     get_Bounds: *const anyopaque,
-    put_Bounds: *const fn (*ICoreWebView2Controller, win.RECT) callconv(.winapi) HRESULT,
+    put_Bounds: *const fn (*ICoreWebView2Controller, RECT) callconv(.winapi) HRESULT,
     get_ZoomFactor: *const anyopaque,
     put_ZoomFactor: *const anyopaque,
     add_ZoomFactorChanged: *const anyopaque,
@@ -244,17 +251,26 @@ pub const CreateCoreWebView2EnvironmentWithOptionsFn = *const fn (
     *ICoreWebView2CreateCoreWebView2EnvironmentCompletedHandler,
 ) callconv(.winapi) HRESULT;
 
+extern "kernel32" fn LoadLibraryW(lpLibFileName: win.LPCWSTR) callconv(.winapi) ?win.HMODULE;
+extern "kernel32" fn FreeLibrary(hLibModule: win.HMODULE) callconv(.winapi) win.BOOL;
+extern "kernel32" fn GetProcAddress(hModule: win.HMODULE, lpProcName: [*:0]const u8) callconv(.winapi) ?*const anyopaque;
+
+/// Stores dynamically resolved native symbol bindings.
 pub const Symbols = struct {
-    loader: std.DynLib,
+    /// Binds `loader` from the native runtime.
+    loader: win.HMODULE,
+    /// Binds `create_environment` from the native runtime.
     create_environment: CreateCoreWebView2EnvironmentWithOptionsFn,
 
     /// Loads the platform symbols.
     pub fn load() !Symbols {
-        var loader = try std.DynLib.open("WebView2Loader.dll");
-        errdefer loader.close();
+        const library_name = std.unicode.utf8ToUtf16LeStringLiteral("WebView2Loader.dll");
+        const loader = LoadLibraryW(library_name) orelse return error.MissingSharedLibrary;
+        errdefer _ = FreeLibrary(loader);
 
-        const create_environment = loader.lookup(CreateCoreWebView2EnvironmentWithOptionsFn, "CreateCoreWebView2EnvironmentWithOptions") orelse
+        const create_environment_proc = GetProcAddress(loader, "CreateCoreWebView2EnvironmentWithOptions") orelse
             return error.MissingDynamicSymbol;
+        const create_environment: CreateCoreWebView2EnvironmentWithOptionsFn = @ptrCast(create_environment_proc);
 
         return .{
             .loader = loader,
@@ -264,7 +280,7 @@ pub const Symbols = struct {
 
     /// Releases resources owned by this value.
     pub fn deinit(self: *Symbols) void {
-        self.loader.close();
+        _ = FreeLibrary(self.loader);
     }
 };
 
diff --git a/src/backends/windows_webview_host.zig b/src/backends/windows_webview_host.zig
index 9895f82..3b4da77 100644
--- a/src/backends/windows_webview_host.zig
+++ b/src/backends/windows_webview_host.zig
@@ -1,5 +1,7 @@
 const std = @import("std");
 const builtin = @import("builtin");
+const thread_compat = @import("thread_compat");
+const time_compat = @import("time_compat");
 const window_style_types = @import("../root/window_style.zig");
 const wv2 = @import("windows_webview/bindings.zig");
 
@@ -7,6 +9,9 @@ const win = std.os.windows;
 
 const WindowStyle = window_style_types.WindowStyle;
 const WindowControl = window_style_types.WindowControl;
+const WPARAM = usize;
+const LPARAM = isize;
+const LRESULT = isize;
 
 const default_width: i32 = 980;
 const default_height: i32 = 660;
@@ -55,6 +60,7 @@ const SWP_SHOWWINDOW: u32 = 0x0040;
 
 const COINIT_APARTMENTTHREADED: u32 = 0x2;
 const ERROR_CLASS_ALREADY_EXISTS: u32 = 1410;
+const S_OK: wv2.HRESULT = 0;
 const webview2_bg_env_name = std.unicode.utf8ToUtf16LeStringLiteral("WEBVIEW2_DEFAULT_BACKGROUND_COLOR");
 const webview2_bg_env_zero = std.unicode.utf8ToUtf16LeStringLiteral("0");
 
@@ -83,6 +89,13 @@ const POINT = extern struct {
     y: i32,
 };
 
+const RECT = extern struct {
+    left: i32,
+    top: i32,
+    right: i32,
+    bottom: i32,
+};
+
 const MINMAXINFO = extern struct {
     ptReserved: POINT,
     ptMaxSize: POINT,
@@ -94,8 +107,8 @@ const MINMAXINFO = extern struct {
 const MSG = extern struct {
     hwnd: ?win.HWND,
     message: u32,
-    wParam: win.WPARAM,
-    lParam: win.LPARAM,
+    wParam: WPARAM,
+    lParam: LPARAM,
     time: u32,
     pt: POINT,
     lPrivate: u32,
@@ -116,7 +129,7 @@ const CREATESTRUCTW = extern struct {
     dwExStyle: u32,
 };
 
-const WNDPROC = *const fn (win.HWND, u32, win.WPARAM, win.LPARAM) callconv(.winapi) win.LRESULT;
+const WNDPROC = *const fn (win.HWND, u32, WPARAM, LPARAM) callconv(.winapi) LRESULT;
 
 const WNDCLASSEXW = extern struct {
     cbSize: u32,
@@ -137,6 +150,8 @@ extern "ole32" fn CoInitializeEx(?*anyopaque, u32) callconv(.winapi) wv2.HRESULT
 extern "ole32" fn CoUninitialize() callconv(.winapi) void;
 extern "ole32" fn CoTaskMemFree(?*anyopaque) callconv(.winapi) void;
 extern "kernel32" fn GetLastError() callconv(.winapi) u32;
+extern "kernel32" fn GetModuleHandleW(?win.LPCWSTR) callconv(.winapi) ?win.HMODULE;
+extern "kernel32" fn SetEnvironmentVariableW(win.LPCWSTR, ?win.LPCWSTR) callconv(.winapi) win.BOOL;
 
 extern "user32" fn RegisterClassExW(*const WNDCLASSEXW) callconv(.winapi) win.ATOM;
 extern "user32" fn UnregisterClassW(win.LPCWSTR, ?win.HINSTANCE) callconv(.winapi) win.BOOL;
@@ -154,61 +169,87 @@ extern "user32" fn CreateWindowExW(
     ?win.HINSTANCE,
     ?*anyopaque,
 ) callconv(.winapi) ?win.HWND;
-extern "user32" fn DefWindowProcW(win.HWND, u32, win.WPARAM, win.LPARAM) callconv(.winapi) win.LRESULT;
+extern "user32" fn DefWindowProcW(win.HWND, u32, WPARAM, LPARAM) callconv(.winapi) LRESULT;
 extern "user32" fn DestroyWindow(win.HWND) callconv(.winapi) win.BOOL;
 extern "user32" fn PostQuitMessage(i32) callconv(.winapi) void;
 extern "user32" fn ShowWindow(win.HWND, i32) callconv(.winapi) win.BOOL;
 extern "user32" fn UpdateWindow(win.HWND) callconv(.winapi) win.BOOL;
 extern "user32" fn PeekMessageW(*MSG, ?win.HWND, u32, u32, u32) callconv(.winapi) win.BOOL;
 extern "user32" fn TranslateMessage(*const MSG) callconv(.winapi) win.BOOL;
-extern "user32" fn DispatchMessageW(*const MSG) callconv(.winapi) win.LRESULT;
-extern "user32" fn GetClientRect(win.HWND, *win.RECT) callconv(.winapi) win.BOOL;
+extern "user32" fn DispatchMessageW(*const MSG) callconv(.winapi) LRESULT;
+extern "user32" fn GetClientRect(win.HWND, *RECT) callconv(.winapi) win.BOOL;
 extern "user32" fn SetWindowPos(win.HWND, ?win.HWND, i32, i32, i32, i32, u32) callconv(.winapi) win.BOOL;
 extern "user32" fn SetWindowLongPtrW(win.HWND, i32, win.LONG_PTR) callconv(.winapi) win.LONG_PTR;
 extern "user32" fn GetWindowLongPtrW(win.HWND, i32) callconv(.winapi) win.LONG_PTR;
 extern "user32" fn SetWindowLongW(win.HWND, i32, i32) callconv(.winapi) i32;
 extern "user32" fn GetWindowLongW(win.HWND, i32) callconv(.winapi) i32;
-extern "user32" fn PostMessageW(win.HWND, u32, win.WPARAM, win.LPARAM) callconv(.winapi) win.BOOL;
-extern "user32" fn SendMessageW(win.HWND, u32, win.WPARAM, win.LPARAM) callconv(.winapi) win.LRESULT;
+extern "user32" fn PostMessageW(win.HWND, u32, WPARAM, LPARAM) callconv(.winapi) win.BOOL;
+extern "user32" fn SendMessageW(win.HWND, u32, WPARAM, LPARAM) callconv(.winapi) LRESULT;
 extern "user32" fn SetWindowTextW(win.HWND, win.LPCWSTR) callconv(.winapi) win.BOOL;
-extern "user32" fn GetWindowRect(win.HWND, *win.RECT) callconv(.winapi) win.BOOL;
+extern "user32" fn GetWindowRect(win.HWND, *RECT) callconv(.winapi) win.BOOL;
 extern "user32" fn SetWindowRgn(win.HWND, ?*anyopaque, win.BOOL) callconv(.winapi) i32;
 extern "user32" fn CreateIconFromResourceEx(?[*]u8, u32, win.BOOL, u32, i32, i32, u32) callconv(.winapi) ?win.HICON;
 extern "user32" fn DestroyIcon(win.HICON) callconv(.winapi) win.BOOL;
 extern "gdi32" fn CreateRoundRectRgn(i32, i32, i32, i32, i32, i32) callconv(.winapi) ?*anyopaque;
 extern "gdi32" fn DeleteObject(?*anyopaque) callconv(.winapi) win.BOOL;
 
+/// Owns platform-native host state and thread-affine resources.
 pub const Host = struct {
+    /// Allocates host-owned buffers and runtime state.
     allocator: std.mem.Allocator,
+    /// Stores the current native window title.
     title: []u8,
+    /// Stores the last applied window style.
     style: WindowStyle,
 
-    mutex: std.Thread.Mutex = .{},
+    /// Stores the mutex.
+    mutex: thread_compat.Mutex = .{},
+    /// Stores the queue.
     queue: std.array_list.Managed(Command),
+    /// Stores the owner thread id.
     owner_thread_id: std.Thread.Id = undefined,
 
+    /// Stores the startup done.
     startup_done: bool = false,
+    /// Stores the startup error.
     startup_error: ?anyerror = null,
+    /// Stores the ui ready.
     ui_ready: bool = false,
+    /// Stores the closed.
     closed: std.atomic.Value(bool) = std.atomic.Value(bool).init(false),
+    /// Stores the shutdown requested.
     shutdown_requested: bool = false,
+    /// Stores the pending async callbacks.
     pending_async_callbacks: usize = 0,
 
+    /// Stores the instance.
     instance: ?win.HINSTANCE = null,
+    /// Stores the class registered.
     class_registered: bool = false,
+    /// Stores the hwnd.
     hwnd: ?win.HWND = null,
+    /// Stores the window icon.
     window_icon: ?win.HICON = null,
+    /// Stores the window destroy started.
     window_destroy_started: bool = false,
 
+    /// Stores the symbols.
     symbols: ?wv2.Symbols = null,
+    /// Stores the com initialized.
     com_initialized: bool = false,
 
+    /// Stores the environment.
     environment: ?*wv2.ICoreWebView2Environment = null,
+    /// Stores the controller.
     controller: ?*wv2.ICoreWebView2Controller = null,
+    /// Stores the webview.
     webview: ?*wv2.ICoreWebView2 = null,
+    /// Stores the title changed token.
     title_changed_token: wv2.EventRegistrationToken = .{ .value = 0 },
+    /// Stores the title handler attached.
     title_handler_attached: bool = false,
 
+    /// Stores the pending url.
     pending_url: ?[]u8 = null,
 
     /// Start.
@@ -361,7 +402,7 @@ fn initializeUiThread(host: *Host) !void {
     host.symbols = symbols;
     host.mutex.unlock();
 
-    if (std.os.windows.kernel32.GetModuleHandleW(null)) |module_handle| {
+    if (GetModuleHandleW(null)) |module_handle| {
         host.instance = @ptrCast(module_handle);
     } else {
         host.instance = null;
@@ -402,7 +443,7 @@ fn waitForStartup(host: *Host) void {
         if (done) return;
 
         const had_activity = pumpMessageLoopStep(host);
-        if (!had_activity) std.Thread.sleep(std.time.ns_per_ms);
+        if (!had_activity) time_compat.sleep(std.time.ns_per_ms);
     }
 }
 
@@ -415,7 +456,7 @@ fn pumpUntilClosed(host: *Host) void {
         host.mutex.unlock();
         if (done) return;
 
-        if (!had_activity) std.Thread.sleep(std.time.ns_per_ms);
+        if (!had_activity) time_compat.sleep(std.time.ns_per_ms);
     }
 }
 
@@ -423,7 +464,7 @@ fn pumpMessageLoopStep(host: *Host) bool {
     var msg: MSG = undefined;
     var had_activity = false;
 
-    while (PeekMessageW(&msg, null, 0, 0, PM_REMOVE) != 0) {
+    while (PeekMessageW(&msg, null, 0, 0, PM_REMOVE).toBool()) {
         had_activity = true;
         if (msg.message == WM_QUIT) {
             host.mutex.lock();
@@ -652,12 +693,7 @@ fn applyStyleUiThread(host: *Host, style: WindowStyle) void {
     _ = SetWindowLongW(hwnd, GWL_STYLE, @as(i32, @bitCast(style_bits)));
 
     const ex_before = @as(u32, @bitCast(@as(i32, @truncate(GetWindowLongW(hwnd, GWL_EXSTYLE)))));
-    var ex_after = ex_before;
-    if (style.transparent) {
-        ex_after |= WS_EX_LAYERED;
-    } else {
-        ex_after &= ~WS_EX_LAYERED;
-    }
+    const ex_after = computeExtendedWindowStyle(ex_before, style);
     _ = SetWindowLongW(hwnd, GWL_EXSTYLE, @as(i32, @bitCast(ex_after)));
 
     _ = SetWindowPos(hwnd, null, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);
@@ -740,13 +776,23 @@ fn computeWindowStyle(style: WindowStyle) u32 {
     return out;
 }
 
+fn computeExtendedWindowStyle(current_ex: u32, style: WindowStyle) u32 {
+    var out = current_ex;
+    if (style.transparent) {
+        out |= WS_EX_LAYERED;
+    } else {
+        out &= ~WS_EX_LAYERED;
+    }
+    return out;
+}
+
 fn createWebViewEnvironment(host: *Host) bool {
     const symbols = host.symbols orelse return false;
 
     if (host.style.transparent) {
-        _ = std.os.windows.kernel32.SetEnvironmentVariableW(webview2_bg_env_name, webview2_bg_env_zero);
+        _ = SetEnvironmentVariableW(webview2_bg_env_name, webview2_bg_env_zero);
     } else {
-        _ = std.os.windows.kernel32.SetEnvironmentVariableW(webview2_bg_env_name, null);
+        _ = SetEnvironmentVariableW(webview2_bg_env_name, null);
     }
 
     retainAsyncCallback(host);
@@ -774,29 +820,39 @@ fn updateControllerBounds(host: *Host) void {
     const hwnd = host.hwnd orelse return;
     const controller = host.controller orelse return;
 
-    var rect: win.RECT = undefined;
-    if (GetClientRect(hwnd, &rect) == 0) return;
-    _ = controller.lpVtbl.put_Bounds(controller, rect);
+    var rect: RECT = undefined;
+    if (!GetClientRect(hwnd, &rect).toBool()) return;
+    const bounds = wv2.RECT{
+        .left = rect.left,
+        .top = rect.top,
+        .right = rect.right,
+        .bottom = rect.bottom,
+    };
+    _ = controller.lpVtbl.put_Bounds(controller, bounds);
 }
 
 fn applyWindowCornerRadius(hwnd: win.HWND, radius: ?u16) void {
     if (radius) |value| {
-        var window_rect: win.RECT = undefined;
-        if (GetWindowRect(hwnd, &window_rect) == 0) return;
+        var window_rect: RECT = undefined;
+        if (!GetWindowRect(hwnd, &window_rect).toBool()) return;
 
         const width = window_rect.right - window_rect.left;
         const height = window_rect.bottom - window_rect.top;
         if (width <= 1 or height <= 1) return;
 
-        const diameter = @max(@as(i32, 2), @as(i32, @intCast(@as(u32, value) * 2)));
+        const diameter = roundedRegionDiameter(value);
         const region = CreateRoundRectRgn(0, 0, width + 1, height + 1, diameter, diameter) orelse return;
-        if (SetWindowRgn(hwnd, region, 1) == 0) {
+        if (SetWindowRgn(hwnd, region, win.BOOL.TRUE) == 0) {
             _ = DeleteObject(region);
         }
         return;
     }
 
-    _ = SetWindowRgn(hwnd, null, 1);
+    _ = SetWindowRgn(hwnd, null, win.BOOL.TRUE);
+}
+
+fn roundedRegionDiameter(radius: u16) i32 {
+    return @max(@as(i32, 2), @as(i32, @intCast(@as(u32, radius) * 2)));
 }
 
 fn applyWindowIcon(host: *Host, hwnd: win.HWND, icon: ?window_style_types.WindowIcon) void {
@@ -817,7 +873,7 @@ fn applyWindowIcon(host: *Host, hwnd: win.HWND, icon: ?window_style_types.Window
     const created = CreateIconFromResourceEx(
         bytes_copy.ptr,
         @as(u32, @intCast(bytes_copy.len)),
-        1,
+        win.BOOL.TRUE,
         0x00030000,
         0,
         0,
@@ -825,8 +881,8 @@ fn applyWindowIcon(host: *Host, hwnd: win.HWND, icon: ?window_style_types.Window
     ) orelse return;
 
     host.window_icon = created;
-    _ = SendMessageW(hwnd, WM_SETICON, ICON_SMALL, @as(win.LPARAM, @intCast(@intFromPtr(created))));
-    _ = SendMessageW(hwnd, WM_SETICON, ICON_BIG, @as(win.LPARAM, @intCast(@intFromPtr(created))));
+    _ = SendMessageW(hwnd, WM_SETICON, ICON_SMALL, @as(LPARAM, @intCast(@intFromPtr(created))));
+    _ = SendMessageW(hwnd, WM_SETICON, ICON_BIG, @as(LPARAM, @intCast(@intFromPtr(created))));
 }
 
 fn applyControllerBackgroundColor(host: *Host) void {
@@ -905,7 +961,7 @@ fn environmentHandlerQueryInterface(
 ) callconv(.winapi) wv2.HRESULT {
     out.* = self;
     _ = environmentHandlerAddRef(self);
-    return win.S_OK;
+    return S_OK;
 }
 
 fn environmentHandlerAddRef(self: *wv2.ICoreWebView2CreateCoreWebView2EnvironmentCompletedHandler) callconv(.winapi) u32 {
@@ -933,7 +989,7 @@ fn environmentHandlerInvoke(
 
     if (!wv2.succeeded(error_code) or created_environment == null) {
         failStartup(host, error.NativeBackendUnavailable);
-        return win.S_OK;
+        return S_OK;
     }
 
     const environment = created_environment.?;
@@ -944,7 +1000,7 @@ fn environmentHandlerInvoke(
     var controller_handler = host.allocator.create(ControllerCompletedHandler) catch {
         releaseAsyncCallback(host);
         failStartup(host, error.NativeBackendUnavailable);
-        return win.S_OK;
+        return S_OK;
     };
     controller_handler.* = .{
         .iface = .{ .lpVtbl = &controller_completed_handler_vtbl },
@@ -956,7 +1012,7 @@ fn environmentHandlerInvoke(
     const hwnd = host.hwnd orelse {
         _ = controllerHandlerRelease(&controller_handler.iface);
         failStartup(host, error.NativeBackendUnavailable);
-        return win.S_OK;
+        return S_OK;
     };
 
     const hr = environment.lpVtbl.CreateCoreWebView2Controller(environment, hwnd, &controller_handler.iface);
@@ -966,7 +1022,7 @@ fn environmentHandlerInvoke(
     }
 
     _ = controllerHandlerRelease(&controller_handler.iface);
-    return win.S_OK;
+    return S_OK;
 }
 
 fn controllerHandlerQueryInterface(
@@ -976,7 +1032,7 @@ fn controllerHandlerQueryInterface(
 ) callconv(.winapi) wv2.HRESULT {
     out.* = self;
     _ = controllerHandlerAddRef(self);
-    return win.S_OK;
+    return S_OK;
 }
 
 fn controllerHandlerAddRef(self: *wv2.ICoreWebView2CreateCoreWebView2ControllerCompletedHandler) callconv(.winapi) u32 {
@@ -1004,7 +1060,7 @@ fn controllerHandlerInvoke(
 
     if (!wv2.succeeded(error_code) or created_controller == null) {
         failStartup(host, error.NativeBackendUnavailable);
-        return win.S_OK;
+        return S_OK;
     }
 
     const controller = created_controller.?;
@@ -1014,7 +1070,7 @@ fn controllerHandlerInvoke(
     var webview: ?*wv2.ICoreWebView2 = null;
     if (!wv2.succeeded(controller.lpVtbl.get_CoreWebView2(controller, &webview)) or webview == null) {
         failStartup(host, error.NativeBackendUnavailable);
-        return win.S_OK;
+        return S_OK;
     }
     const core = webview.?;
     _ = core.lpVtbl.AddRef(core);
@@ -1033,7 +1089,7 @@ fn controllerHandlerInvoke(
 
     finishStartupReady(host);
 
-    return win.S_OK;
+    return S_OK;
 }
 
 fn configureWebViewSettings(webview: *wv2.ICoreWebView2) void {
@@ -1042,10 +1098,10 @@ fn configureWebViewSettings(webview: *wv2.ICoreWebView2) void {
     const s = settings orelse return;
     defer _ = s.lpVtbl.Release(s);
 
-    _ = s.lpVtbl.put_IsScriptEnabled(s, 1);
-    _ = s.lpVtbl.put_IsWebMessageEnabled(s, 1);
-    _ = s.lpVtbl.put_AreDefaultScriptDialogsEnabled(s, 1);
-    _ = s.lpVtbl.put_AreDevToolsEnabled(s, if (builtin.mode == .Debug) 1 else 0);
+    _ = s.lpVtbl.put_IsScriptEnabled(s, win.BOOL.TRUE);
+    _ = s.lpVtbl.put_IsWebMessageEnabled(s, win.BOOL.TRUE);
+    _ = s.lpVtbl.put_AreDefaultScriptDialogsEnabled(s, win.BOOL.TRUE);
+    _ = s.lpVtbl.put_AreDevToolsEnabled(s, win.BOOL.fromBool(builtin.mode == .Debug));
 }
 
 fn attachTitleHandler(host: *Host, webview: *wv2.ICoreWebView2) void {
@@ -1091,7 +1147,7 @@ fn titleHandlerQueryInterface(
 ) callconv(.winapi) wv2.HRESULT {
     out.* = self;
     _ = titleHandlerAddRef(self);
-    return win.S_OK;
+    return S_OK;
 }
 
 fn titleHandlerAddRef(self: *wv2.ICoreWebView2DocumentTitleChangedEventHandler) callconv(.winapi) u32 {
@@ -1117,21 +1173,21 @@ fn titleHandlerInvoke(
     const host = handler.host;
     _ = sender;
 
-    const webview = host.webview orelse return win.S_OK;
+    const webview = host.webview orelse return S_OK;
 
     var raw_title: ?win.PWSTR = null;
-    if (!wv2.succeeded(webview.lpVtbl.get_DocumentTitle(webview, &raw_title))) return win.S_OK;
-    const title_ptr = raw_title orelse return win.S_OK;
+    if (!wv2.succeeded(webview.lpVtbl.get_DocumentTitle(webview, &raw_title))) return S_OK;
+    const title_ptr = raw_title orelse return S_OK;
     defer CoTaskMemFree(title_ptr);
 
     if (host.hwnd) |hwnd| {
         _ = SetWindowTextW(hwnd, title_ptr);
     }
 
-    return win.S_OK;
+    return S_OK;
 }
 
-fn wndProc(hwnd: win.HWND, msg: u32, wparam: win.WPARAM, lparam: win.LPARAM) callconv(.winapi) win.LRESULT {
+fn wndProc(hwnd: win.HWND, msg: u32, wparam: WPARAM, lparam: LPARAM) callconv(.winapi) LRESULT {
     if (msg == WM_NCCREATE) {
         const create_struct: *const CREATESTRUCTW = @ptrFromInt(@as(usize, @bitCast(lparam)));
         if (create_struct.lpCreateParams) |param| {
@@ -1217,3 +1273,17 @@ test "computeWindowStyle maps frameless and resizable flags" {
     try std.testing.expect((classic_fixed & WS_THICKFRAME) == 0);
     try std.testing.expect((classic_fixed & WS_MAXIMIZEBOX) == 0);
 }
+
+test "computeExtendedWindowStyle toggles layered flag for transparency" {
+    const base: u32 = 0;
+    const transparent = computeExtendedWindowStyle(base, .{ .transparent = true });
+    try std.testing.expect((transparent & WS_EX_LAYERED) != 0);
+
+    const restored = computeExtendedWindowStyle(transparent, .{ .transparent = false });
+    try std.testing.expect((restored & WS_EX_LAYERED) == 0);
+}
+
+test "roundedRegionDiameter doubles radius with a minimum of two" {
+    try std.testing.expectEqual(@as(i32, 2), roundedRegionDiameter(0));
+    try std.testing.expectEqual(@as(i32, 6), roundedRegionDiameter(3));
+}
diff --git a/src/bridge/template.zig b/src/bridge/template.zig
index 4b8307b..c07a661 100644
--- a/src/bridge/template.zig
+++ b/src/bridge/template.zig
@@ -1,15 +1,23 @@
 const std = @import("std");
 const helpers = @import("runtime_helpers.zig");
 
+/// Stores rpc function meta.
 pub const RpcFunctionMeta = struct {
+    /// Stores the name.
     name: []const u8,
+    /// Stores the arity.
     arity: usize,
+    /// Stores the ts arg signature.
     ts_arg_signature: []const u8 = "",
+    /// Stores the ts return type.
     ts_return_type: []const u8 = "unknown",
 };
 
+/// Configures render options.
 pub const RenderOptions = struct {
+    /// Stores the namespace.
     namespace: []const u8 = "webuiRpc",
+    /// Stores the rpc route.
     rpc_route: []const u8 = "/webui/rpc",
 };
 
@@ -40,58 +48,57 @@ fn renderWithRuntimeHelpers(
     var out = std.array_list.Managed(u8).init(allocator);
     errdefer out.deinit();
 
-    const writer = out.writer();
-    try writer.writeAll("// Generated by tools/bridge_gen.zig\n");
-    try writer.writeAll(runtime_helpers_js);
-    try writer.writeAll("\nconst webuiRpcEndpoint = ");
-    try writeJsonLiteral(allocator, writer, options.rpc_route);
-    try writer.writeAll(";\n");
-    try writer.writeAll("\nconst ");
-    try writer.writeAll(options.namespace);
-    try writer.writeAll(" = Object.freeze({\n");
+    try out.appendSlice("// Generated by tools/bridge_gen.zig\n");
+    try out.appendSlice(runtime_helpers_js);
+    try out.appendSlice("\nconst webuiRpcEndpoint = ");
+    try writeJsonLiteral(allocator, &out, options.rpc_route);
+    try out.appendSlice(";\n");
+    try out.appendSlice("\nconst ");
+    try out.appendSlice(options.namespace);
+    try out.appendSlice(" = Object.freeze({\n");
 
     for (functions) |fn_meta| {
-        try writer.writeAll("  ");
-        try writer.writeAll(fn_meta.name);
-        try writer.writeAll(": async (");
+        try out.appendSlice("  ");
+        try out.appendSlice(fn_meta.name);
+        try out.appendSlice(": async (");
 
         var i: usize = 0;
         while (i < fn_meta.arity) : (i += 1) {
-            if (i != 0) try writer.writeAll(", ");
-            try writer.print("arg{d}", .{i});
+            if (i != 0) try out.appendSlice(", ");
+            try out.print("arg{d}", .{i});
         }
 
-        try writer.writeAll(") => await webuiInvoke(webuiRpcEndpoint, ");
-        try writeJsonLiteral(allocator, writer, fn_meta.name);
-        try writer.writeAll(", [");
+        try out.appendSlice(") => await webuiInvoke(webuiRpcEndpoint, ");
+        try writeJsonLiteral(allocator, &out, fn_meta.name);
+        try out.appendSlice(", [");
         i = 0;
         while (i < fn_meta.arity) : (i += 1) {
-            if (i != 0) try writer.writeAll(", ");
-            try writer.print("arg{d}", .{i});
+            if (i != 0) try out.appendSlice(", ");
+            try out.print("arg{d}", .{i});
         }
-        try writer.writeAll("]),\n");
+        try out.appendSlice("]),\n");
     }
 
     // Keep generated bridge JS usable from classic <script src="..."> loads.
     // Do not emit ESM `export` statements here: examples and legacy pages rely
     // on the global namespace binding being available immediately.
-    try writer.writeAll("});\nif (typeof globalThis !== \"undefined\") { globalThis.");
-    try writer.writeAll(options.namespace);
-    try writer.writeAll(" = ");
-    try writer.writeAll(options.namespace);
-    try writer.writeAll("; }\n");
+    try out.appendSlice("});\nif (typeof globalThis !== \"undefined\") { globalThis.");
+    try out.appendSlice(options.namespace);
+    try out.appendSlice(" = ");
+    try out.appendSlice(options.namespace);
+    try out.appendSlice("; }\n");
 
     return out.toOwnedSlice();
 }
 
 fn writeJsonLiteral(
     allocator: std.mem.Allocator,
-    writer: anytype,
+    out: *std.array_list.Managed(u8),
     value: anytype,
 ) !void {
     const encoded = try std.json.Stringify.valueAlloc(allocator, value, .{});
     defer allocator.free(encoded);
-    try writer.writeAll(encoded);
+    try out.appendSlice(encoded);
 }
 
 /// Renders the JavaScript bridge for `RpcStruct` at comptime.
@@ -144,39 +151,38 @@ pub fn renderTypeScriptDeclarations(
     var out = std.array_list.Managed(u8).init(allocator);
     errdefer out.deinit();
 
-    const writer = out.writer();
-    try writer.writeAll("// Generated by tools/bridge_gen.zig\n");
-    try writer.writeAll("export interface WebuiRpcClient {\n");
+    try out.appendSlice("// Generated by tools/bridge_gen.zig\n");
+    try out.appendSlice("export interface WebuiRpcClient {\n");
     for (functions) |fn_meta| {
-        try writer.writeAll("  ");
-        try writer.writeAll(fn_meta.name);
-        try writer.writeAll("(");
+        try out.appendSlice("  ");
+        try out.appendSlice(fn_meta.name);
+        try out.appendSlice("(");
         if (fn_meta.ts_arg_signature.len > 0) {
-            try writer.writeAll(fn_meta.ts_arg_signature);
+            try out.appendSlice(fn_meta.ts_arg_signature);
         } else {
             var i: usize = 0;
             while (i < fn_meta.arity) : (i += 1) {
-                if (i != 0) try writer.writeAll(", ");
-                try writer.print("arg{d}: unknown", .{i});
+                if (i != 0) try out.appendSlice(", ");
+                try out.print("arg{d}: unknown", .{i});
             }
         }
-        try writer.writeAll("): Promise<");
+        try out.appendSlice("): Promise<");
         if (fn_meta.ts_return_type.len > 0) {
-            try writer.writeAll(fn_meta.ts_return_type);
+            try out.appendSlice(fn_meta.ts_return_type);
         } else {
-            try writer.writeAll("unknown");
+            try out.appendSlice("unknown");
         }
-        try writer.writeAll(">;\n");
+        try out.appendSlice(">;\n");
     }
-    try writer.writeAll("}\n");
-    try writer.writeAll("export declare const ");
-    try writer.writeAll(options.namespace);
-    try writer.writeAll(": WebuiRpcClient;\n");
-    try writer.writeAll("declare global {\n");
-    try writer.writeAll("  var ");
-    try writer.writeAll(options.namespace);
-    try writer.writeAll(": WebuiRpcClient;\n");
-    try writer.writeAll("}\n");
+    try out.appendSlice("}\n");
+    try out.appendSlice("export declare const ");
+    try out.appendSlice(options.namespace);
+    try out.appendSlice(": WebuiRpcClient;\n");
+    try out.appendSlice("declare global {\n");
+    try out.appendSlice("  var ");
+    try out.appendSlice(options.namespace);
+    try out.appendSlice(": WebuiRpcClient;\n");
+    try out.appendSlice("}\n");
     return out.toOwnedSlice();
 }
 
diff --git a/src/env_compat.zig b/src/env_compat.zig
new file mode 100644
index 0000000..ee1ea0a
--- /dev/null
+++ b/src/env_compat.zig
@@ -0,0 +1,23 @@
+const std = @import("std");
+const builtin = @import("builtin");
+
+fn processEnvironFromRuntime() std.process.Environ {
+    if (builtin.is_test) return std.testing.environ;
+
+    const threaded = std.Options.debug_threaded_io orelse return .empty;
+    return threaded.environ.process_environ;
+}
+
+fn loadRuntimeEnvironMap(allocator: std.mem.Allocator) !std.process.Environ.Map {
+    return processEnvironFromRuntime().createMap(allocator);
+}
+
+/// Returns a copied environment variable value.
+pub fn getEnvVarOwned(allocator: std.mem.Allocator, key: []const u8) ![]u8 {
+    return processEnvironFromRuntime().getAlloc(allocator, key);
+}
+
+/// Returns a mutable environment map.
+pub fn getEnvMap(allocator: std.mem.Allocator) !std.process.Environ.Map {
+    return loadRuntimeEnvironMap(allocator);
+}
diff --git a/src/io_compat.zig b/src/io_compat.zig
new file mode 100644
index 0000000..6483c18
--- /dev/null
+++ b/src/io_compat.zig
@@ -0,0 +1,5 @@
+const std = @import("std");
+const builtin = @import("builtin");
+
+/// Shared I/O context for std.Io APIs across runtime and tests.
+pub const io: std.Io = if (builtin.is_test) std.testing.io else std.Options.debug_io;
diff --git a/src/main.zig b/src/main.zig
index e25f728..a383fea 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -1,6 +1,8 @@
 const std = @import("std");
 const webui = @import("webui");
+const time_compat = @import("time_compat");
 
+/// Stores rpc methods.
 pub const rpc_methods = struct {
     /// Returns add.
     pub fn add(a: i64, b: i64) i64 {
@@ -14,15 +16,13 @@ pub const rpc_methods = struct {
 };
 
 /// Returns main.
-pub fn main() !void {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
-    defer _ = gpa.deinit();
+pub fn main(init: std.process.Init) !void {
+    const allocator = init.gpa;
 
-    const allocator = gpa.allocator();
-    const args = try std.process.argsAlloc(allocator);
-    defer std.process.argsFree(allocator, args);
-
-    const demo_url = if (args.len > 1) args[1] else null;
+    var args_iter = try init.minimal.args.iterateAllocator(allocator);
+    defer args_iter.deinit();
+    _ = args_iter.next(); // exe name
+    const demo_url = args_iter.next();
 
     var service = try webui.Service.init(allocator, rpc_methods, .{
         .app = .{
@@ -72,7 +72,7 @@ pub fn main() !void {
     std.debug.print("WebUI running. Press Ctrl+C to exit.\n", .{});
 
     while (!service.shouldExit()) {
-        std.Thread.sleep(20 * std.time.ns_per_ms);
+        time_compat.sleep(20 * std.time.ns_per_ms);
     }
     service.shutdown();
 }
diff --git a/src/network/civetweb.zig b/src/network/civetweb.zig
index 2e50dc2..fb8013b 100644
--- a/src/network/civetweb.zig
+++ b/src/network/civetweb.zig
@@ -1,20 +1,34 @@
 const std = @import("std");
 
+/// Stores types.
 pub const types = struct {
+    /// Enumerates http method values.
     pub const HttpMethod = enum {
+        /// Selects `get`.
         get,
+        /// Selects `post`.
         post,
+        /// Selects `put`.
         put,
+        /// Selects `patch`.
         patch,
+        /// Selects `delete`.
         delete,
+        /// Selects `options`.
         options,
+        /// Selects `head`.
         head,
     };
 
+    /// Stores request.
     pub const Request = struct {
+        /// Stores the method.
         method: HttpMethod,
+        /// Stores the path.
         path: []const u8,
+        /// Stores the body.
         body: []const u8,
+        /// Stores the headers.
         headers: std.StringHashMap([]const u8),
 
         /// Initializes this value.
@@ -33,17 +47,24 @@ pub const types = struct {
         }
     };
 
+    /// Stores response.
     pub const Response = struct {
+        /// Stores the status.
         status: u16 = 200,
+        /// Stores the body.
         body: []const u8 = "",
+        /// Stores the content type.
         content_type: []const u8 = "text/plain; charset=utf-8",
     };
 };
 
+/// Stores handle form.
 pub const handle_form = struct {
     /// Parses form-urlencoded data.
     pub fn parseFormUrlEncoded(
+        /// Stores the allocator.
         allocator: std.mem.Allocator,
+        /// Stores the payload.
         payload: []const u8,
     ) !std.StringHashMap([]const u8) {
         var out = std.StringHashMap([]const u8).init(allocator);
@@ -62,6 +83,7 @@ pub const handle_form = struct {
     }
 };
 
+/// Stores matcher.
 pub const matcher = struct {
     /// Returns whether the haystack starts with the needle, ignoring ASCII case.
     pub fn startsWithIgnoreCase(haystack: []const u8, needle: []const u8) bool {
@@ -70,6 +92,7 @@ pub const matcher = struct {
     }
 };
 
+/// Stores md5.
 pub const md5 = struct {
     /// Digest hex.
     pub fn digestHex(input: []const u8, allocator: std.mem.Allocator) ![]u8 {
@@ -79,6 +102,7 @@ pub const md5 = struct {
     }
 };
 
+/// Stores response.
 pub const response = struct {
     /// Text.
     pub fn text(status: u16, body: []const u8) types.Response {
@@ -99,6 +123,7 @@ pub const response = struct {
     }
 };
 
+/// Stores sha1.
 pub const sha1 = struct {
     /// Digest hex.
     pub fn digestHex(input: []const u8, allocator: std.mem.Allocator) ![]u8 {
@@ -108,6 +133,7 @@ pub const sha1 = struct {
     }
 };
 
+/// Stores sort.
 pub const sort = struct {
     /// Sorts strings in place.
     pub fn sortStrings(items: [][]const u8) void {
@@ -119,8 +145,11 @@ pub const sort = struct {
     }
 };
 
+/// Stores server.
 pub const Server = struct {
+    /// Stores the allocator.
     allocator: std.mem.Allocator,
+    /// Stores the port.
     port: u16,
 
     /// Initializes this value.
diff --git a/src/network/https_server.zig b/src/network/https_server.zig
index 87bca64..3db0495 100644
--- a/src/network/https_server.zig
+++ b/src/network/https_server.zig
@@ -1,40 +1,57 @@
 const std = @import("std");
 const tls = @import("tls");
+const time_compat = @import("time_compat");
+const env_compat = @import("env_compat");
+const io_compat = @import("io_compat");
 
+/// Stores connection.
 pub const Connection = struct {
-    stream: std.net.Stream,
+    /// Stores the stream.
+    stream: std.Io.net.Stream,
+    /// Stores the read buffer.
     read_buffer: [tls.input_buffer_len]u8 = undefined,
+    /// Stores the write buffer.
     write_buffer: [tls.output_buffer_len]u8 = undefined,
-    reader: std.net.Stream.Reader = undefined,
-    writer: std.net.Stream.Writer = undefined,
+    /// Stores the reader.
+    reader: std.Io.net.Stream.Reader = undefined,
+    /// Stores the writer.
+    writer: std.Io.net.Stream.Writer = undefined,
+    /// Stores the tls conn.
     tls_conn: tls.Connection = undefined,
 
     /// Init server.
     pub fn initServer(
+        /// Stores the allocator.
         allocator: std.mem.Allocator,
-        stream: std.net.Stream,
+        /// Stores the stream.
+        stream: std.Io.net.Stream,
+        /// Stores the cert pem.
         cert_pem: []const u8,
+        /// Stores the key pem.
         key_pem: []const u8,
     ) !Connection {
         var conn: Connection = .{
             .stream = stream,
         };
-        conn.reader = conn.stream.reader(&conn.read_buffer);
-        conn.writer = conn.stream.writer(&conn.write_buffer);
+        conn.reader = conn.stream.reader(io_compat.io, &conn.read_buffer);
+        conn.writer = conn.stream.writer(io_compat.io, &conn.write_buffer);
 
         const cert_path, const key_path = try writeTempPemFiles(allocator, cert_pem, key_pem);
         defer {
-            std.fs.deleteFileAbsolute(cert_path) catch {};
-            std.fs.deleteFileAbsolute(key_path) catch {};
+            std.Io.Dir.deleteFileAbsolute(io_compat.io, cert_path) catch {};
+            std.Io.Dir.deleteFileAbsolute(io_compat.io, key_path) catch {};
             allocator.free(cert_path);
             allocator.free(key_path);
         }
 
-        var auth = try tls.config.CertKeyPair.fromFilePathAbsolute(allocator, cert_path, key_path);
+        var auth = try tls.config.CertKeyPair.fromFilePathAbsolute(allocator, io_compat.io, cert_path, key_path);
         defer auth.deinit(allocator);
+        var prng = std.Random.DefaultPrng.init(@intCast(@abs(time_compat.nanoTimestamp())));
 
-        conn.tls_conn = try tls.server(conn.reader.interface(), &conn.writer.interface, .{
+        conn.tls_conn = try tls.server(&conn.reader.interface, &conn.writer.interface, .{
+            .rng = prng.random(),
             .auth = &auth,
+            .now = std.Io.Timestamp.now(io_compat.io, .real),
         });
         return conn;
     }
@@ -52,23 +69,35 @@ pub const Connection = struct {
     /// Close.
     pub fn close(self: *Connection) void {
         self.tls_conn.close() catch {};
-        self.stream.close();
+        self.stream.close(io_compat.io);
     }
 };
 
 /// Peeks the first byte from a stream without consuming it permanently.
-pub fn peekFirstByte(stream: std.net.Stream) !?u8 {
-    var byte: [1]u8 = undefined;
-    const n = std.posix.recv(stream.handle, &byte, std.posix.MSG.PEEK) catch |err| switch (err) {
-        error.WouldBlock,
-        error.ConnectionResetByPeer,
-        error.ConnectionTimedOut,
-        error.SocketNotConnected,
-        => return null,
-        else => return err,
-    };
-    if (n == 0) return null;
-    return byte[0];
+pub fn peekFirstByte(stream: std.Io.net.Stream) !?u8 {
+    var data: [1]u8 = undefined;
+    var incoming: [1]std.Io.net.IncomingMessage = .{std.Io.net.IncomingMessage.init};
+    const maybe_err, const count = stream.socket.receiveManyTimeout(
+        io_compat.io,
+        &incoming,
+        &data,
+        .{ .peek = true },
+        .none,
+    );
+    if (maybe_err) |err| {
+        const err_name = @errorName(err);
+        if (std.mem.eql(u8, err_name, "ConnectionResetByPeer") or
+            std.mem.eql(u8, err_name, "ConnectionTimedOut") or
+            std.mem.eql(u8, err_name, "SocketNotConnected") or
+            std.mem.eql(u8, err_name, "EndOfStream"))
+        {
+            return null;
+        }
+        return err;
+    }
+    if (count == 0) return null;
+    if (incoming[0].data.len == 0) return null;
+    return incoming[0].data[0];
 }
 
 /// Returns whether the first byte matches a TLS ClientHello record.
@@ -83,35 +112,35 @@ fn writeTempPemFiles(
     key_pem: []const u8,
 ) !struct { []u8, []u8 } {
     const tmp_base = if (@import("builtin").os.tag == .windows)
-        std.process.getEnvVarOwned(allocator, "TEMP") catch
-            std.process.getEnvVarOwned(allocator, "TMP") catch
+        env_compat.getEnvVarOwned(allocator, "TEMP") catch
+            env_compat.getEnvVarOwned(allocator, "TMP") catch
             try allocator.dupe(u8, "C:\\Temp")
     else
-        std.process.getEnvVarOwned(allocator, "TMPDIR") catch try allocator.dupe(u8, "/tmp");
+        env_compat.getEnvVarOwned(allocator, "TMPDIR") catch try allocator.dupe(u8, "/tmp");
     defer allocator.free(tmp_base);
 
-    const stamp: u64 = @intCast(@abs(std.time.nanoTimestamp()));
+    const stamp: u64 = @intCast(@abs(time_compat.nanoTimestamp()));
     const cert_path = try std.fmt.allocPrint(
         allocator,
         "{s}{c}webui-tls-cert-{d}.pem",
-        .{ std.mem.trimRight(u8, tmp_base, "/\\"), std.fs.path.sep, stamp },
+        .{ std.mem.trimEnd(u8, tmp_base, "/\\"), std.fs.path.sep, stamp },
     );
     errdefer allocator.free(cert_path);
     const key_path = try std.fmt.allocPrint(
         allocator,
         "{s}{c}webui-tls-key-{d}.pem",
-        .{ std.mem.trimRight(u8, tmp_base, "/\\"), std.fs.path.sep, stamp },
+        .{ std.mem.trimEnd(u8, tmp_base, "/\\"), std.fs.path.sep, stamp },
     );
     errdefer allocator.free(key_path);
 
-    const cert_file = try std.fs.createFileAbsolute(cert_path, .{ .truncate = true });
-    defer cert_file.close();
-    try cert_file.writeAll(cert_pem);
-    errdefer std.fs.deleteFileAbsolute(cert_path) catch {};
-    const key_file = try std.fs.createFileAbsolute(key_path, .{ .truncate = true });
-    defer key_file.close();
-    try key_file.writeAll(key_pem);
-    errdefer std.fs.deleteFileAbsolute(key_path) catch {};
+    const cert_file = try std.Io.Dir.createFileAbsolute(io_compat.io, cert_path, .{ .truncate = true });
+    defer cert_file.close(io_compat.io);
+    try cert_file.writeStreamingAll(io_compat.io, cert_pem);
+    errdefer std.Io.Dir.deleteFileAbsolute(io_compat.io, cert_path) catch {};
+    const key_file = try std.Io.Dir.createFileAbsolute(io_compat.io, key_path, .{ .truncate = true });
+    defer key_file.close(io_compat.io);
+    try key_file.writeStreamingAll(io_compat.io, key_pem);
+    errdefer std.Io.Dir.deleteFileAbsolute(io_compat.io, key_path) catch {};
 
     return .{ cert_path, key_path };
 }
diff --git a/src/network/tls_runtime.zig b/src/network/tls_runtime.zig
index 195f6a6..22c5e98 100644
--- a/src/network/tls_runtime.zig
+++ b/src/network/tls_runtime.zig
@@ -1,27 +1,45 @@
 const std = @import("std");
 const x509_self_signed = @import("x509_self_signed.zig");
 
+/// Configures tls options.
 pub const TlsOptions = struct {
+    /// Stores the enabled.
     enabled: bool = false,
+    /// Stores the cert pem.
     cert_pem: ?[]const u8 = null,
+    /// Stores the key pem.
     key_pem: ?[]const u8 = null,
+    /// Stores the auto generate if missing.
     auto_generate_if_missing: bool = true,
 };
 
+/// Describes tls info.
 pub const TlsInfo = struct {
+    /// Stores the enabled.
     enabled: bool,
+    /// Stores the generated.
     generated: bool,
+    /// Stores the fingerprint sha256.
     fingerprint_sha256: ?[]const u8,
+    /// Stores the scheme.
     scheme: []const u8,
 };
 
+/// Stores runtime.
 pub const Runtime = struct {
+    /// Stores the enabled.
     enabled: bool,
+    /// Stores the generated.
     generated: bool,
+    /// Stores the cert pem.
     cert_pem: ?[]u8,
+    /// Stores the key pem.
     key_pem: ?[]u8,
+    /// Stores the fingerprint sha256.
     fingerprint_sha256: ?[]u8,
+    /// Stores the allocator.
     allocator: std.mem.Allocator,
+    /// Stores the auto generate if missing.
     auto_generate_if_missing: bool,
 
     /// Initializes this value.
@@ -159,7 +177,7 @@ fn buildSha256Hex(allocator: std.mem.Allocator, bytes: []const u8) ![]u8 {
 }
 
 test "tls runtime validates and fingerprints user supplied pem" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     const cert_pem =
@@ -186,7 +204,7 @@ test "tls runtime validates and fingerprints user supplied pem" {
 }
 
 test "tls runtime auto generates ephemeral certificate at runtime" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var runtime_a = try Runtime.init(gpa.allocator(), .{
@@ -210,7 +228,7 @@ test "tls runtime auto generates ephemeral certificate at runtime" {
 }
 
 test "tls runtime errors when cert missing and auto generation disabled" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var runtime = try Runtime.init(gpa.allocator(), .{
diff --git a/src/network/x509_self_signed.zig b/src/network/x509_self_signed.zig
index 17593e1..3ec7dbf 100644
--- a/src/network/x509_self_signed.zig
+++ b/src/network/x509_self_signed.zig
@@ -1,7 +1,10 @@
 const std = @import("std");
 
+/// Stores pem pair.
 pub const PemPair = struct {
+    /// Stores the cert pem.
     cert_pem: []u8,
+    /// Stores the key pem.
     key_pem: []u8,
 };
 
@@ -13,8 +16,12 @@ const oid_subject_alt_name = [_]u8{ 0x55, 0x1D, 0x11 };
 
 /// Generates a localhost self-signed PEM certificate pair.
 pub fn generateLocalhostPemPair(allocator: std.mem.Allocator) !PemPair {
+    var threaded: std.Io.Threaded = .init(allocator, .{});
+    defer threaded.deinit();
+    const io = threaded.io();
+
     const Scheme = std.crypto.sign.ecdsa.EcdsaP256Sha256;
-    const key_pair = Scheme.KeyPair.generate();
+    const key_pair = Scheme.KeyPair.generate(io);
     const secret_key = key_pair.secret_key.toBytes();
     const public_key_sec1 = key_pair.public_key.toUncompressedSec1();
 
@@ -43,7 +50,7 @@ pub fn generateLocalhostPemPair(allocator: std.mem.Allocator) !PemPair {
     try tbs_content.appendSlice(version_explicit);
 
     var serial: [16]u8 = undefined;
-    std.crypto.random.bytes(&serial);
+    io.random(&serial);
     serial[0] &= 0x7F;
     if (serial[0] == 0) serial[0] = 1;
     try appendDerInteger(&tbs_content, &serial);
@@ -227,7 +234,7 @@ fn appendDerTaggedOctets(list: *std.array_list.Managed(u8), tag: u8, value: []co
 }
 
 fn appendDerInteger(list: *std.array_list.Managed(u8), integer_bytes: []const u8) !void {
-    var trimmed = std.mem.trimLeft(u8, integer_bytes, "\x00");
+    var trimmed = std.mem.trimStart(u8, integer_bytes, "\x00");
     if (trimmed.len == 0) trimmed = &.{0};
 
     var value = std.array_list.Managed(u8).init(list.allocator);
@@ -283,20 +290,20 @@ fn pemEncodeBlock(allocator: std.mem.Allocator, label: []const u8, raw: []const
     var out = std.array_list.Managed(u8).init(allocator);
     errdefer out.deinit();
 
-    try out.writer().print("-----BEGIN {s}-----\n", .{label});
+    try out.print("-----BEGIN {s}-----\n", .{label});
     var offset: usize = 0;
     while (offset < encoded.len) : (offset += 64) {
         const end = @min(offset + 64, encoded.len);
         try out.appendSlice(encoded[offset..end]);
         try out.append('\n');
     }
-    try out.writer().print("-----END {s}-----", .{label});
+    try out.print("-----END {s}-----", .{label});
 
     return out.toOwnedSlice();
 }
 
 test "generateLocalhostPemPair emits parseable PEM envelope" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     const pair = try generateLocalhostPemPair(gpa.allocator());
diff --git a/src/ported/browser_discovery.zig b/src/ported/browser_discovery.zig
index 3dcdd20..4ea4035 100644
--- a/src/ported/browser_discovery.zig
+++ b/src/ported/browser_discovery.zig
@@ -1,41 +1,75 @@
 const std = @import("std");
 const builtin = @import("builtin");
+const env_compat = @import("env_compat");
+const io_compat = @import("io_compat");
 
+/// Enumerates browser kind values.
 pub const BrowserKind = enum {
+    /// Selects `chrome`.
     chrome,
+    /// Selects `edge`.
     edge,
+    /// Selects `safari`.
     safari,
+    /// Selects `firefox`.
     firefox,
+    /// Selects `chromium`.
     chromium,
+    /// Selects `opera`.
     opera,
+    /// Selects `brave`.
     brave,
+    /// Selects `vivaldi`.
     vivaldi,
+    /// Selects `epic`.
     epic,
+    /// Selects `yandex`.
     yandex,
+    /// Selects `duckduckgo`.
     duckduckgo,
+    /// Selects `tor`.
     tor,
+    /// Selects `librewolf`.
     librewolf,
+    /// Selects `mullvad`.
     mullvad,
+    /// Selects `arc`.
     arc,
+    /// Selects `sidekick`.
     sidekick,
+    /// Selects `shift`.
     shift,
+    /// Selects `operagx`.
     operagx,
+    /// Selects `palemoon`.
     palemoon,
+    /// Selects `sigmaos`.
     sigmaos,
 };
 
+/// Enumerates browser source values.
 pub const BrowserSource = enum {
+    /// Selects `explicit_env`.
     explicit_env,
+    /// Selects `known_path`.
     known_path,
+    /// Selects `path_env`.
     path_env,
+    /// Selects `app_bundle`.
     app_bundle,
+    /// Selects `directory_scan`.
     directory_scan,
 };
 
+/// Stores browser install.
 pub const BrowserInstall = struct {
+    /// Stores the kind.
     kind: BrowserKind,
+    /// Stores the path.
     path: []u8,
+    /// Stores the source.
     source: BrowserSource,
+    /// Stores the score.
     score: i32,
 };
 
@@ -121,7 +155,7 @@ fn collectExplicitEnv(
     dedup_keys: *std.array_list.Managed([]u8),
 ) !void {
     for (env_browser_keys, 0..) |key, key_index| {
-        const value = std.process.getEnvVarOwned(allocator, key) catch continue;
+        const value = env_compat.getEnvVarOwned(allocator, key) catch continue;
         defer allocator.free(value);
 
         const resolved = try resolveCommandOrPath(allocator, value);
@@ -179,7 +213,7 @@ fn collectPathEnv(
     dedup: *std.StringHashMap(usize),
     dedup_keys: *std.array_list.Managed([]u8),
 ) !void {
-    const path_env = std.process.getEnvVarOwned(allocator, "PATH") catch return;
+    const path_env = env_compat.getEnvVarOwned(allocator, "PATH") catch return;
     defer allocator.free(path_env);
 
     var dir_it = std.mem.splitScalar(u8, path_env, std.fs.path.delimiter);
@@ -372,7 +406,7 @@ fn extractCommandToken(allocator: std.mem.Allocator, raw_value: []const u8) !?[]
 }
 
 fn resolveInPath(allocator: std.mem.Allocator, command: []const u8) !?[]u8 {
-    const path_env = std.process.getEnvVarOwned(allocator, "PATH") catch return null;
+    const path_env = env_compat.getEnvVarOwned(allocator, "PATH") catch return null;
     defer allocator.free(path_env);
 
     var dir_it = std.mem.splitScalar(u8, path_env, std.fs.path.delimiter);
@@ -445,10 +479,10 @@ fn normalizePathKey(allocator: std.mem.Allocator, path: []const u8) ![]u8 {
 }
 
 fn getHomeDir(allocator: std.mem.Allocator) ?[]u8 {
-    const home = std.process.getEnvVarOwned(allocator, "HOME") catch null;
+    const home = env_compat.getEnvVarOwned(allocator, "HOME") catch null;
     if (home) |h| return h;
     if (builtin.os.tag == .windows) {
-        return std.process.getEnvVarOwned(allocator, "USERPROFILE") catch null;
+        return env_compat.getEnvVarOwned(allocator, "USERPROFILE") catch null;
     }
     return null;
 }
@@ -480,7 +514,7 @@ fn expandPathTemplate(allocator: std.mem.Allocator, template: []const u8) ![]u8
             };
 
             const key = template[i + 1 .. end];
-            const value = std.process.getEnvVarOwned(allocator, key) catch null;
+            const value = env_compat.getEnvVarOwned(allocator, key) catch null;
             defer if (value) |v| allocator.free(v);
 
             if (value) |v| {
@@ -514,13 +548,13 @@ fn expandPathTemplate(allocator: std.mem.Allocator, template: []const u8) ![]u8
 }
 
 fn pathExists(path: []const u8) bool {
-    std.fs.cwd().access(path, .{}) catch return false;
+    std.Io.Dir.cwd().access(io_compat.io, path, .{}) catch return false;
     return true;
 }
 
 fn directoryExists(path: []const u8) bool {
-    var dir = std.fs.cwd().openDir(path, .{}) catch return false;
-    dir.close();
+    var dir = std.Io.Dir.cwd().openDir(io_compat.io, path, .{}) catch return false;
+    dir.close(io_compat.io);
     return true;
 }
 
diff --git a/src/ported/runtime_env.zig b/src/ported/runtime_env.zig
index ed1a330..525741b 100644
--- a/src/ported/runtime_env.zig
+++ b/src/ported/runtime_env.zig
@@ -1,16 +1,18 @@
 const std = @import("std");
 const builtin = @import("builtin");
+const env_compat = @import("env_compat");
+const io_compat = @import("io_compat");
 
 /// Returns whether a macOS-targeted binary is currently running under Darling on Linux.
 pub fn isDarlingRuntime() bool {
     if (builtin.os.tag != .macos) return false;
 
-    if (std.process.getEnvVarOwned(std.heap.page_allocator, "DPREFIX")) |value| {
+    if (env_compat.getEnvVarOwned(std.heap.page_allocator, "DPREFIX")) |value| {
         std.heap.page_allocator.free(value);
         return true;
     } else |_| {}
 
-    std.fs.accessAbsolute("/Volumes/SystemRoot", .{}) catch return false;
+    std.Io.Dir.accessAbsolute(io_compat.io, "/Volumes/SystemRoot", .{}) catch return false;
     return true;
 }
 
diff --git a/src/ported/webui.zig b/src/ported/webui.zig
index d51ffd2..5067add 100644
--- a/src/ported/webui.zig
+++ b/src/ported/webui.zig
@@ -1,5 +1,8 @@
 const std = @import("std");
 const builtin = @import("builtin");
+const time_compat = @import("time_compat");
+const env_compat = @import("env_compat");
+const io_compat = @import("io_compat");
 const browser_discovery = @import("browser_discovery.zig");
 const runtime_env = @import("runtime_env.zig");
 const window_style_types = @import("../root/window_style.zig");
@@ -10,76 +13,125 @@ const platform_browser_host = switch (builtin.os.tag) {
     else => struct {},
 };
 
+/// Stores browser launch.
 pub const BrowserLaunch = struct {
+    /// Stores the pid.
     pid: ?i64 = null,
+    /// Whether is child process.
     is_child_process: bool = false,
+    /// Stores the lifecycle linked.
     lifecycle_linked: bool = false,
+    /// Stores the kind.
     kind: ?browser_discovery.BrowserKind = null,
+    /// Stores the surface mode.
     surface_mode: BrowserSurfaceMode = .tab,
+    /// Stores the used system fallback.
     used_system_fallback: bool = false,
+    /// Stores the profile dir.
     profile_dir: ?[]u8 = null,
+    /// Stores the profile ownership.
     profile_ownership: BrowserLaunchProfileOwnership = .none,
 };
 
+/// Enumerates browser launch profile ownership values.
 pub const BrowserLaunchProfileOwnership = enum {
+    /// Selects `none`.
     none,
+    /// Selects `ephemeral_owned`.
     ephemeral_owned,
+    /// Selects `persistent_user`.
     persistent_user,
 };
 
+/// Enumerates browser prompt preset values.
 pub const BrowserPromptPreset = enum {
+    /// Selects `quiet_default`.
     quiet_default,
+    /// Selects `browser_default`.
     browser_default,
 };
 
+/// Stores browser prompt policy.
 pub const BrowserPromptPolicy = struct {
+    /// Stores the preset.
     preset: BrowserPromptPreset = .quiet_default,
+    /// Stores the no first run.
     no_first_run: ?bool = null,
+    /// Stores the no default browser check.
     no_default_browser_check: ?bool = null,
+    /// Stores the disable notifications.
     disable_notifications: ?bool = null,
+    /// Stores the disable save password bubble.
     disable_save_password_bubble: ?bool = null,
+    /// Stores the disable autofill keyboard accessor.
     disable_autofill_keyboard_accessor: ?bool = null,
+    /// Stores the disable infobars.
     disable_infobars: ?bool = null,
+    /// Stores the exclude enable automation.
     exclude_enable_automation: ?bool = null,
+    /// Stores the edge hide first run experience.
     edge_hide_first_run_experience: ?bool = null,
+    /// Stores the brave make default false.
     brave_make_default_false: ?bool = null,
+    /// Stores the brave disable product analytics prompt.
     brave_disable_product_analytics_prompt: ?bool = null,
 };
 
+/// Enumerates browser surface mode values.
 pub const BrowserSurfaceMode = enum {
+    /// Selects `tab`.
     tab,
+    /// Selects `app_window`.
     app_window,
+    /// Selects `native_webview_host`.
     native_webview_host,
 };
 
+/// Enumerates browser fallback mode values.
 pub const BrowserFallbackMode = enum {
+    /// Selects `allow_system`.
     allow_system,
+    /// Selects `strict`.
     strict,
 };
 
+/// Represents profile path spec variants.
 pub const ProfilePathSpec = union(enum) {
     default,
     ephemeral,
+    /// Stores the custom.
     custom: []const u8,
 };
 
+/// Represents profile rule target variants.
 pub const ProfileRuleTarget = union(enum) {
     webview,
     browser_any,
+    /// Stores the browser kind.
     browser_kind: browser_discovery.BrowserKind,
 };
 
+/// Stores profile rule.
 pub const ProfileRule = struct {
+    /// Stores the target.
     target: ProfileRuleTarget,
+    /// Stores the path.
     path: ProfilePathSpec,
 };
 
+/// Configures browser launch options.
 pub const BrowserLaunchOptions = struct {
+    /// Stores the prompt policy.
     prompt_policy: BrowserPromptPolicy = .{},
+    /// Stores the extra args.
     extra_args: []const []const u8 = &.{},
+    /// Stores the proxy server.
     proxy_server: ?[]const u8 = null,
+    /// Stores the surface mode.
     surface_mode: BrowserSurfaceMode = .tab,
+    /// Stores the fallback mode.
     fallback_mode: BrowserFallbackMode = .allow_system,
+    /// Stores the profile rules.
     profile_rules: []const ProfileRule = &.{},
 };
 
@@ -106,6 +158,50 @@ pub fn openInBrowser(
 ) !BrowserLaunch {
     const installs = browser_discovery.discoverInstalledBrowsers(allocator) catch &[_]browser_discovery.BrowserInstall{};
     defer if (installs.len > 0) browser_discovery.freeInstalls(allocator, installs);
+    return openInBrowserWithInstalls(allocator, url, style, launch_options, installs);
+}
+
+fn openInBrowserWithInstalls(
+    allocator: std.mem.Allocator,
+    url: []const u8,
+    style: window_style_types.WindowStyle,
+    launch_options: BrowserLaunchOptions,
+    installs: []const browser_discovery.BrowserInstall,
+) !BrowserLaunch {
+    if (launch_options.surface_mode == .tab) {
+        if (hasExplicitInstallOverride(installs)) {
+            for (installs) |install| {
+                if (install.source != .explicit_env) continue;
+                if (!openUrlInInstall(allocator, install, url)) continue;
+                return .{
+                    .pid = null,
+                    .is_child_process = false,
+                    .lifecycle_linked = false,
+                    .kind = install.kind,
+                    .surface_mode = .tab,
+                    .used_system_fallback = false,
+                };
+            }
+        }
+
+        if (launch_options.fallback_mode == .allow_system) {
+            if (try launchSystemFallback(allocator, url)) |launch| return launch;
+        }
+
+        for (installs) |install| {
+            if (!openUrlInInstall(allocator, install, url)) continue;
+            return .{
+                .pid = null,
+                .is_child_process = false,
+                .lifecycle_linked = false,
+                .kind = install.kind,
+                .surface_mode = .tab,
+                .used_system_fallback = false,
+            };
+        }
+
+        return error.BrowserLaunchFailed;
+    }
 
     if (launch_options.surface_mode == .native_webview_host) {
         // Native-webview mode is handled in-process by platform backends.
@@ -184,7 +280,7 @@ pub fn openInBrowser(
 
 /// Terminates a tracked browser process.
 pub fn terminateBrowserProcess(allocator: std.mem.Allocator, pid: i64) void {
-    if (pid <= 0) return;
+    if (pid == 0) return;
 
     switch (builtin.os.tag) {
         .linux, .windows, .macos => platform_browser_host.terminateProcess(allocator, pid),
@@ -200,14 +296,14 @@ pub fn cleanupBrowserProfileDir(
     ownership: BrowserLaunchProfileOwnership,
 ) void {
     if (ownership == .ephemeral_owned) {
-        std.fs.deleteTreeAbsolute(profile_dir) catch {};
+        std.Io.Dir.cwd().deleteTree(io_compat.io, profile_dir) catch {};
     }
     allocator.free(profile_dir);
 }
 
 /// Returns whether the tracked process is still alive.
 pub fn isProcessAlive(pid: i64) bool {
-    if (pid <= 0) return false;
+    if (pid == 0) return false;
     return switch (builtin.os.tag) {
         .linux, .windows, .macos => platform_browser_host.isProcessAlive(std.heap.page_allocator, pid),
         .wasi => false,
@@ -217,7 +313,7 @@ pub fn isProcessAlive(pid: i64) bool {
 
 /// Returns whether a linked child process has exited.
 pub fn linkedChildExited(pid: i64) bool {
-    if (pid <= 0) return true;
+    if (pid == 0) return true;
     return switch (builtin.os.tag) {
         .windows, .wasi => false,
         else => linkedChildExitedPosix(pid),
@@ -226,7 +322,7 @@ pub fn linkedChildExited(pid: i64) bool {
 
 /// Applies a window control action to a browser process.
 pub fn controlBrowserWindow(allocator: std.mem.Allocator, pid: i64, cmd: window_style_types.WindowControl) bool {
-    if (pid <= 0) return false;
+    if (pid == 0) return false;
 
     return switch (builtin.os.tag) {
         .linux, .windows, .macos => platform_browser_host.controlWindow(allocator, pid, cmd),
@@ -256,6 +352,20 @@ pub fn openUrlInExistingBrowserKind(
     return false;
 }
 
+const DirectUrlLaunchSpec = struct {
+    args: [4][]const u8 = .{""} ** 4,
+    len: usize = 0,
+
+    fn append(self: *DirectUrlLaunchSpec, arg: []const u8) void {
+        self.args[self.len] = arg;
+        self.len += 1;
+    }
+
+    fn slice(self: *const DirectUrlLaunchSpec) []const []const u8 {
+        return self.args[0..self.len];
+    }
+};
+
 const LaunchSpec = struct {
     args: [24][]const u8 = .{""} ** 24,
     len: usize = 0,
@@ -332,6 +442,60 @@ fn launchBrowserCandidate(
     return null;
 }
 
+fn openUrlInInstall(
+    allocator: std.mem.Allocator,
+    install: browser_discovery.BrowserInstall,
+    url: []const u8,
+) bool {
+    var spec = directUrlLaunchSpec(install.kind, url);
+    return switch (builtin.os.tag) {
+        .linux, .windows, .macos => blk: {
+            const launched = platform_browser_host.launchTracked(allocator, install.path, spec.slice()) catch null;
+            break :blk launched != null;
+        },
+        else => false,
+    };
+}
+
+fn hasExplicitInstallOverride(installs: []const browser_discovery.BrowserInstall) bool {
+    for (installs) |install| {
+        if (install.source == .explicit_env) return true;
+    }
+    return false;
+}
+
+fn directUrlLaunchSpec(kind: browser_discovery.BrowserKind, url: []const u8) DirectUrlLaunchSpec {
+    var spec: DirectUrlLaunchSpec = .{};
+    switch (kind) {
+        .chrome,
+        .edge,
+        .chromium,
+        .opera,
+        .brave,
+        .vivaldi,
+        .epic,
+        .yandex,
+        .duckduckgo,
+        .arc,
+        .sidekick,
+        .shift,
+        .operagx,
+        .firefox,
+        .tor,
+        .librewolf,
+        .mullvad,
+        .palemoon,
+        => {
+            spec.append("--new-window");
+            spec.append(url);
+        },
+        else => {
+            spec.append(url);
+        },
+    }
+    return spec;
+}
+
 fn launchSpecForKind(
     allocator: std.mem.Allocator,
     kind: browser_discovery.BrowserKind,
@@ -347,7 +511,6 @@ fn launchSpecForKind(
         const app_window_mode = launch_options.surface_mode == .app_window or
             launch_options.surface_mode == .native_webview_host;
         if (app_window_mode) {
-            try spec.append("--new-window");
             try spec.appendOwnedFmt(allocator, "--app={s}", .{url});
         } else {
             // Web tab mode: open a normal browser tab/session URL.
@@ -574,16 +737,16 @@ const ResolvedProfile = struct {
 /// Resolves the base profile directory prefix.
 pub fn resolveProfileBasePrefix(allocator: std.mem.Allocator) ![]u8 {
     const base = switch (builtin.os.tag) {
-        .windows => std.process.getEnvVarOwned(allocator, "LOCALAPPDATA") catch
-            std.process.getEnvVarOwned(allocator, "APPDATA") catch
+        .windows => env_compat.getEnvVarOwned(allocator, "LOCALAPPDATA") catch
+            env_compat.getEnvVarOwned(allocator, "APPDATA") catch
             try allocator.dupe(u8, "C:\\"),
         .macos => blk: {
-            const home = std.process.getEnvVarOwned(allocator, "HOME") catch try allocator.dupe(u8, "/tmp");
+            const home = env_compat.getEnvVarOwned(allocator, "HOME") catch try allocator.dupe(u8, "/tmp");
             defer allocator.free(home);
             break :blk try std.fs.path.join(allocator, &.{ home, "Library", "Application Support" });
         },
-        else => std.process.getEnvVarOwned(allocator, "XDG_CONFIG_HOME") catch blk: {
-            const home = std.process.getEnvVarOwned(allocator, "HOME") catch try allocator.dupe(u8, "/tmp");
+        else => env_compat.getEnvVarOwned(allocator, "XDG_CONFIG_HOME") catch blk: {
+            const home = env_compat.getEnvVarOwned(allocator, "HOME") catch try allocator.dupe(u8, "/tmp");
             defer allocator.free(home);
             break :blk try std.fs.path.join(allocator, &.{ home, ".config" });
         },
@@ -603,14 +766,14 @@ pub fn defaultWebviewProfilePath(allocator: std.mem.Allocator) ![]u8 {
 
 fn maybeCreateIsolatedProfileDir(allocator: std.mem.Allocator) !?[]u8 {
     const temp_base = switch (builtin.os.tag) {
-        .windows => std.process.getEnvVarOwned(allocator, "TEMP") catch
-            std.process.getEnvVarOwned(allocator, "TMP") catch
+        .windows => env_compat.getEnvVarOwned(allocator, "TEMP") catch
+            env_compat.getEnvVarOwned(allocator, "TMP") catch
             try allocator.dupe(u8, "C:\\Temp"),
-        else => std.process.getEnvVarOwned(allocator, "TMPDIR") catch try allocator.dupe(u8, "/tmp"),
+        else => env_compat.getEnvVarOwned(allocator, "TMPDIR") catch try allocator.dupe(u8, "/tmp"),
     };
     defer allocator.free(temp_base);
 
-    const stamp: u64 = @intCast(@abs(std.time.nanoTimestamp()));
+    const stamp: u64 = @intCast(@abs(time_compat.nanoTimestamp()));
 
     var attempt: u8 = 0;
     while (attempt < 8) : (attempt += 1) {
@@ -620,7 +783,7 @@ fn maybeCreateIsolatedProfileDir(allocator: std.mem.Allocator) !?[]u8 {
             stamp,
             attempt,
         });
-        std.fs.makeDirAbsolute(dir) catch |err| {
+        std.Io.Dir.cwd().createDirPath(io_compat.io, dir) catch |err| {
             if (err == error.PathAlreadyExists) {
                 allocator.free(dir);
                 continue;
@@ -636,14 +799,7 @@ fn maybeCreateIsolatedProfileDir(allocator: std.mem.Allocator) !?[]u8 {
 
 fn ensureProfileDirExists(path: []const u8) !bool {
     if (path.len == 0) return false;
-    if (std.fs.path.isAbsolute(path)) {
-        std.fs.makeDirAbsolute(path) catch |err| switch (err) {
-            error.PathAlreadyExists => {},
-            else => return false,
-        };
-        return true;
-    }
-    std.fs.cwd().makePath(path) catch |err| switch (err) {
+    std.Io.Dir.cwd().createDirPath(io_compat.io, path) catch |err| switch (err) {
         error.PathAlreadyExists => {},
         else => return false,
     };
@@ -779,7 +935,7 @@ fn ensureBrowserKindProfileSuffix(
 }
 
 fn trimTrailingPathSeparators(path: []const u8) []const u8 {
-    return std.mem.trimRight(u8, path, "/\\");
+    return std.mem.trimEnd(u8, path, "/\\");
 }
 
 fn ensureTrailingSeparatorOwned(allocator: std.mem.Allocator, path: []const u8) ![]u8 {
@@ -790,78 +946,41 @@ fn ensureTrailingSeparatorOwned(allocator: std.mem.Allocator, path: []const u8)
     return std.fmt.allocPrint(allocator, "{s}{c}", .{ path, std.fs.path.sep });
 }
 
-fn runCommandCaptureStdout(allocator: std.mem.Allocator, argv: []const []const u8) ![]u8 {
-    var child = std.process.Child.init(argv, allocator);
-    child.stdin_behavior = .Ignore;
-    child.stdout_behavior = .Pipe;
-    child.stderr_behavior = .Ignore;
-
-    try child.spawn();
-    defer {
-        _ = child.wait() catch {};
-    }
-
-    const out = if (child.stdout) |*stdout_file|
-        try stdout_file.readToEndAlloc(allocator, 32 * 1024)
-    else
-        try allocator.dupe(u8, "");
-    return out;
-}
+const command_timeout: std.Io.Timeout = .{
+    .duration = .{
+        .raw = .{ .nanoseconds = 2 * std.time.ns_per_s },
+        .clock = .boot,
+    },
+};
 
 fn runCommandNoCapture(allocator: std.mem.Allocator, argv: []const []const u8) !bool {
-    var child = std.process.Child.init(argv, allocator);
-    child.stdin_behavior = .Ignore;
-    child.stdout_behavior = .Ignore;
-    child.stderr_behavior = .Ignore;
-
-    const term = child.spawnAndWait() catch return false;
-    return switch (term) {
-        .Exited => |code| code == 0,
+    var env_map = try env_compat.getEnvMap(allocator);
+    defer env_map.deinit();
+
+    var threaded: std.Io.Threaded = .init(allocator, .{});
+    defer threaded.deinit();
+
+    const result = std.process.run(allocator, threaded.io(), .{
+        .argv = argv,
+        .environ_map = &env_map,
+        .stdout_limit = .limited(1024),
+        .stderr_limit = .limited(1024),
+        .timeout = command_timeout,
+    }) catch return false;
+    defer allocator.free(result.stdout);
+    defer allocator.free(result.stderr);
+    return switch (result.term) {
+        .exited => |code| code == 0,
         else => false,
     };
 }
 
-fn terminateBrowserProcessPosix(pid_value: i64) void {
-    const pid: std.posix.pid_t = @intCast(pid_value);
-    std.posix.kill(pid, std.posix.SIG.TERM) catch {};
-    std.posix.kill(pid, std.posix.SIG.KILL) catch {};
-}
-
 fn isProcessAlivePosix(pid_value: i64) bool {
-    const pid: std.posix.pid_t = @intCast(pid_value);
-    std.posix.kill(pid, 0) catch |err| {
-        return switch (err) {
-            error.PermissionDenied => true,
-            else => false,
-        };
-    };
-
-    if (builtin.os.tag == .linux and isZombieProcessLinux(pid)) return false;
-    return true;
-}
-
-fn isZombieProcessLinux(pid: std.posix.pid_t) bool {
-    if (builtin.os.tag != .linux) return false;
-
-    var path_buf: [64]u8 = undefined;
-    const stat_path = std.fmt.bufPrint(&path_buf, "/proc/{d}/stat", .{pid}) catch return false;
-
-    var stat_file = std.fs.openFileAbsolute(stat_path, .{}) catch return false;
-    defer stat_file.close();
-
-    var stat_buf: [1024]u8 = undefined;
-    const stat_len = stat_file.readAll(&stat_buf) catch return false;
-    const stat = stat_buf[0..stat_len];
-
-    const close_paren = std.mem.lastIndexOfScalar(u8, stat, ')') orelse return false;
-    if (close_paren + 2 >= stat.len) return false;
-    return stat[close_paren + 2] == 'Z';
+    return platform_browser_host.isProcessAlive(std.heap.page_allocator, pid_value);
 }
 
 fn linkedChildExitedPosix(pid_value: i64) bool {
-    const pid: std.posix.pid_t = @intCast(pid_value);
-    const result = std.posix.waitpid(pid, std.posix.W.NOHANG);
-    return result.pid == pid;
+    return !isProcessAlivePosix(pid_value);
 }
 
 test "quiet prompt policy injects suppression flags for chromium family" {
@@ -910,8 +1029,8 @@ test "chromium isolated launch adds dedicated user-data-dir argument" {
     defer std.testing.allocator.free(expected_arg);
     try std.testing.expect(containsArg(spec.args[0..spec.len], expected_arg));
 
-    var dir = try std.fs.openDirAbsolute(profile_dir, .{});
-    dir.close();
+    var dir = try std.Io.Dir.openDirAbsolute(io_compat.io, profile_dir, .{});
+    dir.close(io_compat.io);
 }
 
 test "chromium default launch uses browser default profile" {
@@ -972,6 +1091,47 @@ test "chromium launch uses tab mode when app mode is not required" {
     try std.testing.expect(!containsArg(spec.args[0..spec.len], "--new-window"));
 }
 
+test "direct URL launch spec prefers a visible new window for chromium browsers" {
+    const chromium = directUrlLaunchSpec(.brave, "http://127.0.0.1:4010/");
+    try std.testing.expectEqual(@as(usize, 2), chromium.len);
+    try std.testing.expectEqualStrings("--new-window", chromium.args[0]);
+    try std.testing.expectEqualStrings("http://127.0.0.1:4010/", chromium.args[1]);
+
+    const safari = directUrlLaunchSpec(.safari, "http://127.0.0.1:4011/");
+    try std.testing.expectEqual(@as(usize, 1), safari.len);
+    try std.testing.expectEqualStrings("http://127.0.0.1:4011/", safari.args[0]);
+}
+
+test "tab launch prefers system fallback before discovered browser installs" {
+    if (builtin.os.tag == .windows) return error.SkipZigTest;
+
+    var gpa = std.heap.DebugAllocator(.{}){};
+    defer _ = gpa.deinit();
+
+    const install_path = switch (builtin.os.tag) {
+        .macos => "/usr/bin/true",
+        else => "/bin/true",
+    };
+
+    const installs = [_]browser_discovery.BrowserInstall{
+        .{
+            .kind = .brave,
+            .path = @constCast(install_path),
+            .source = .known_path,
+            .score = 1,
+        },
+    };
+
+    const launch = try openInBrowserWithInstalls(gpa.allocator(), "http://127.0.0.1:4012/", .{}, .{
+        .surface_mode = .tab,
+        .fallback_mode = .allow_system,
+    }, installs[0..]);
+
+    try std.testing.expect(launch.used_system_fallback);
+    try std.testing.expectEqual(@as(?browser_discovery.BrowserKind, null), launch.kind);
+    try std.testing.expectEqual(@as(BrowserSurfaceMode, .tab), launch.surface_mode);
+}
+
 test "chromium launch keeps app mode arguments when required" {
     var spec = try launchSpecForKind(std.testing.allocator, .chrome, "http://127.0.0.1:3042/", .{
         .size = .{ .width = 900, .height = 700 },
@@ -981,8 +1141,10 @@ test "chromium launch keeps app mode arguments when required" {
     defer spec.deinit(std.testing.allocator);
 
     try std.testing.expect(containsArgWithPrefix(spec.args[0..spec.len], "--app=http://127.0.0.1:3042/"));
-    try std.testing.expect(containsArg(spec.args[0..spec.len], "--new-window"));
+    try std.testing.expect(!containsArg(spec.args[0..spec.len], "--new-window"));
     try std.testing.expect(containsArg(spec.args[0..spec.len], "--window-size=900,700"));
+    try std.testing.expect(!containsArgWithPrefix(spec.args[0..spec.len], "--user-data-dir="));
+    try std.testing.expect(spec.profile_dir == null);
 }
 
 test "profile rule resolution uses first matching browser rule" {
diff --git a/src/ported/webview.zig b/src/ported/webview.zig
index 1c58a3e..2d84e02 100644
--- a/src/ported/webview.zig
+++ b/src/ported/webview.zig
@@ -17,9 +17,13 @@ const platform_webview_host = switch (builtin.os.tag) {
     else => @compileError("Unsupported Backend"),
 };
 
+/// Represents window content variants.
 pub const WindowContent = union(enum) {
+    /// Stores the html.
     html: []const u8,
+    /// Stores the file.
     file: []const u8,
+    /// Stores the url.
     url: []const u8,
 };
 
@@ -40,18 +44,31 @@ test "linux webview target defaults to compatibility runtime" {
     try std.testing.expectEqual(api_types.LinuxWebViewTarget.webview, backend.linux_webview_target);
 }
 
+/// Stores platform web view.
 pub const PlatformWebView = struct {
+    /// Whether native enabled.
     native_enabled: bool = false,
+    /// Stores the linux webview target.
     linux_webview_target: api_types.LinuxWebViewTarget = .webview,
+    /// Stores the window id.
     window_id: usize = 0,
+    /// Stores the title.
     title: []const u8 = "",
+    /// Stores the style.
     style: style_types.WindowStyle = .{},
+    /// Stores the hidden.
     hidden: bool = false,
+    /// Stores the maximized.
     maximized: bool = false,
+    /// Stores the native host ready.
     native_host_ready: bool = false,
+    /// Stores the host.
     host: ?*platform_webview_host.Host = null,
+    /// Stores the browser kind.
     browser_kind: ?browser_discovery.BrowserKind = null,
+    /// Stores the browser pid.
     browser_pid: ?i64 = null,
+    /// Stores the browser is child.
     browser_is_child: bool = false,
 
     /// Initializes this value.
@@ -148,9 +165,11 @@ pub const PlatformWebView = struct {
 
     /// Shows supported content in the native host.
     pub fn showContent(self: *PlatformWebView, content: anytype) !void {
+        const host = self.host orelse return error.NativeBackendUnavailable;
         const Content = @TypeOf(content);
         if (@hasField(Content, "url")) {
-            try self.navigate(@field(content, "url"));
+            try host.navigate(@field(content, "url"));
+            self.native_host_ready = host.isReady();
             return;
         }
         return error.UnsupportedWindowContent;
@@ -170,17 +189,17 @@ pub const PlatformWebView = struct {
 
     /// Navigate.
     pub fn navigate(self: *PlatformWebView, url: []const u8) !void {
-        if (!self.native_host_ready) return error.NativeBackendUnavailable;
         const host = self.host orelse return error.NativeBackendUnavailable;
         try host.navigate(url);
+        self.native_host_ready = host.isReady();
     }
 
     /// Apply style.
     pub fn applyStyle(self: *PlatformWebView, style: style_types.WindowStyle) !void {
         self.style = style;
-        if (!self.native_host_ready) return;
         const host = self.host orelse return;
         try host.applyStyle(style);
+        self.native_host_ready = host.isReady();
     }
 
     /// Control.
diff --git a/src/root.zig b/src/root.zig
index d8b8fc2..632eb7b 100644
--- a/src/root.zig
+++ b/src/root.zig
@@ -97,12 +97,16 @@ pub const RuntimeRequirement = api_types.RuntimeRequirement;
 pub const EffectiveCapabilities = api_types.EffectiveCapabilities;
 pub const ServiceOptions = api_types.ServiceOptions;
 
+/// Stores test helpers.
 pub const test_helpers = struct {
     pub const readAllFromStream = net_io.readAllFromStream;
+    pub const readFromPlainStream = net_io.readFromPlainStream;
+    pub const readExactBufferedFromStream = net_io.readExactBufferedFromStream;
     pub const httpRoundTrip = net_io.httpRoundTrip;
     pub const httpRoundTripWithHeaders = net_io.httpRoundTripWithHeaders;
     pub const readHttpHeadersFromStream = net_io.readHttpHeadersFromStream;
     pub const httpResponseBody = net_io.httpResponseBody;
+    pub const writeAllToStream = net_io.writeAllToStream;
 };
 
 pub const DiagnosticHandler = window_state.DiagnosticHandler;
diff --git a/src/root/api_types.zig b/src/root/api_types.zig
index 50c16fe..102bb01 100644
--- a/src/root/api_types.zig
+++ b/src/root/api_types.zig
@@ -7,6 +7,7 @@ const runtime_requirements = @import("runtime_requirements.zig");
 const window_style_types = @import("window_style.zig");
 const logging = @import("logging.zig");
 
+/// Stores build flags.
 pub const BuildFlags = struct {
     pub const dynamic = build_options.dynamic;
     pub const enable_tls = build_options.enable_tls;
@@ -16,28 +17,45 @@ pub const BuildFlags = struct {
     pub const linux_webview_target = build_options.linux_webview_target;
 };
 
+/// Enumerates dispatcher mode values.
 pub const DispatcherMode = enum {
+    /// Selects `sync`.
     sync,
+    /// Selects `threaded`.
     threaded,
+    /// Selects `custom`.
     custom,
 };
 
+/// Enumerates transport mode values.
 pub const TransportMode = enum {
+    /// Selects `browser_fallback`.
     browser_fallback,
+    /// Selects `native_webview`.
     native_webview,
 };
 
+/// Enumerates launch surface values.
 pub const LaunchSurface = enum {
+    /// Selects `native_webview`.
     native_webview,
+    /// Selects `browser_window`.
     browser_window,
+    /// Selects `web_url`.
     web_url,
 };
 
+/// Stores launch policy.
 pub const LaunchPolicy = struct {
+    /// Stores the first.
     first: LaunchSurface = .native_webview,
+    /// Stores the second.
     second: ?LaunchSurface = .browser_window,
+    /// Stores the third.
     third: ?LaunchSurface = .web_url,
+    /// Stores the app mode required.
     app_mode_required: bool = true,
+    /// Stores the allow dual surface.
     allow_dual_surface: bool = false,
 
     /// Returns the default native-webview-first launch policy.
@@ -70,28 +88,44 @@ pub const LaunchPolicy = struct {
     }
 };
 
+/// Enumerates fallback reason values.
 pub const FallbackReason = enum {
+    /// Selects `native_backend_unavailable`.
     native_backend_unavailable,
+    /// Selects `unsupported_style`.
     unsupported_style,
+    /// Selects `launch_failed`.
     launch_failed,
+    /// Selects `dependency_missing`.
     dependency_missing,
 };
 
+/// Enumerates linux web view target values.
 pub const LinuxWebViewTarget = enum {
     // Default target used by generic `webview` mode on Linux.
     // Uses WebKit2GTK 4.1 with 4.0 fallback.
+    /// Selects `webview`.
     webview,
     // Explicit opt-in target for GTK4/WebKitGTK 6.
+    /// Selects `webkitgtk_6`.
     webkitgtk_6,
 };
 
+/// Stores runtime render state.
 pub const RuntimeRenderState = struct {
+    /// Stores the active transport.
     active_transport: TransportMode = .browser_fallback,
+    /// Stores the active surface.
     active_surface: LaunchSurface = .web_url,
+    /// Stores the fallback applied.
     fallback_applied: bool = false,
+    /// Stores the fallback reason.
     fallback_reason: ?FallbackReason = null,
+    /// Stores the launch policy.
     launch_policy: LaunchPolicy = .{},
+    /// Stores the using system fallback launcher.
     using_system_fallback_launcher: bool = false,
+    /// Stores the browser process.
     browser_process: ?struct {
         pid: i64,
         kind: ?browser_discovery.BrowserKind,
@@ -99,55 +133,95 @@ pub const RuntimeRenderState = struct {
     } = null,
 };
 
+/// Enumerates diagnostic category values.
 pub const DiagnosticCategory = enum {
+    /// Selects `transport`.
     transport,
+    /// Selects `browser_launch`.
     browser_launch,
+    /// Selects `rpc`.
     rpc,
+    /// Selects `websocket`.
     websocket,
+    /// Selects `tls`.
     tls,
+    /// Selects `lifecycle`.
     lifecycle,
+    /// Selects `runtime_requirements`.
     runtime_requirements,
 };
 
+/// Enumerates diagnostic severity values.
 pub const DiagnosticSeverity = enum {
+    /// Selects `debug`.
     debug,
+    /// Selects `info`.
     info,
+    /// Selects `warn`.
     warn,
+    /// Selects `err`.
     err,
 };
 
+/// Stores diagnostic.
 pub const Diagnostic = struct {
+    /// Stores the code.
     code: []const u8,
+    /// Stores the category.
     category: DiagnosticCategory,
+    /// Stores the severity.
     severity: DiagnosticSeverity,
+    /// Stores the message.
     message: []const u8,
+    /// Stores the window id.
     window_id: usize,
+    /// Stores the timestamp ms.
     timestamp_ms: i64,
 };
 
+/// Enumerates event kind values.
 pub const EventKind = enum {
+    /// Selects `connected`.
     connected,
+    /// Selects `disconnected`.
     disconnected,
+    /// Selects `navigation`.
     navigation,
+    /// Selects `rpc`.
     rpc,
+    /// Selects `raw`.
     raw,
+    /// Selects `window_state`.
     window_state,
+    /// Selects `window_capability`.
     window_capability,
+    /// Selects `close_requested`.
     close_requested,
 };
 
+/// Configures bridge options.
 pub const BridgeOptions = struct {
+    /// Stores the namespace.
     namespace: []const u8 = "webuiRpc",
+    /// Stores the script route.
     script_route: []const u8 = "/webui_bridge.js",
+    /// Stores the rpc route.
     rpc_route: []const u8 = "/webui/rpc",
 };
 
+/// Stores event.
 pub const Event = struct {
+    /// Stores the window id.
     window_id: usize,
+    /// Stores the kind.
     kind: EventKind,
+    /// Stores the name.
     name: []const u8,
+    /// Stores the payload.
     payload: []const u8,
+    /// Stores the client id.
     client_id: ?usize = null,
+    /// Stores the connection id.
     connection_id: ?usize = null,
 };
 
@@ -163,84 +237,139 @@ pub const CustomDispatcher = *const fn (
     args: []const std.json.Value,
 ) anyerror![]u8;
 
+/// Configures rpc options.
 pub const RpcOptions = struct {
+    /// Stores the dispatcher mode.
     dispatcher_mode: DispatcherMode = .threaded,
+    /// Stores the custom dispatcher.
     custom_dispatcher: ?CustomDispatcher = null,
+    /// Stores the custom context.
     custom_context: ?*anyopaque = null,
+    /// Stores the bridge options.
     bridge_options: BridgeOptions = .{},
+    /// Stores the threaded poll interval ns.
     threaded_poll_interval_ns: u64 = 2 * std.time.ns_per_ms,
 };
 
+/// Configures app options.
 pub const AppOptions = struct {
+    /// Stores the launch policy.
     launch_policy: LaunchPolicy = .{},
+    /// Stores the linux webview target.
     linux_webview_target: LinuxWebViewTarget = .webview,
+    /// Whether enable tls.
     enable_tls: bool = build_options.enable_tls,
+    /// Stores the tls.
     tls: @import("../network/tls_runtime.zig").TlsOptions = .{
         .enabled = build_options.enable_tls,
     },
+    /// Whether enable webui log.
     enable_webui_log: bool = build_options.enable_webui_log,
+    /// Stores the log sink.
     log_sink: logging.Sink = .{},
+    /// Stores the public network.
     public_network: bool = false,
+    /// Stores the browser launch.
     browser_launch: core_runtime.BrowserLaunchOptions = .{},
+    /// Stores the window fallback emulation.
     window_fallback_emulation: bool = true,
 };
 
+/// Configures window options.
 pub const WindowOptions = struct {
+    /// Stores the window id.
     window_id: ?usize = null,
+    /// Stores the title.
     title: []const u8 = "WebUI Zig",
+    /// Stores the style.
     style: window_style_types.WindowStyle = .{},
 };
 
+/// Represents window content variants.
 pub const WindowContent = union(enum) {
+    /// Stores the html.
     html: []const u8,
+    /// Stores the file.
     file: []const u8,
+    /// Stores the url.
     url: []const u8,
 };
 
+/// Captures window control result.
 pub const WindowControlResult = struct {
+    /// Stores the success.
     success: bool = true,
+    /// Stores the emulation.
     emulation: ?[]const u8 = null,
+    /// Stores the closed.
     closed: bool = false,
+    /// Stores the warning.
     warning: ?[]const u8 = null,
 };
 
+/// Represents script target variants.
 pub const ScriptTarget = union(enum) {
     window_default,
+    /// Stores the client connection.
     client_connection: usize,
 };
 
+/// Configures script options.
 pub const ScriptOptions = struct {
+    /// Stores the target.
     target: ScriptTarget = .window_default,
+    /// Stores the timeout ms.
     timeout_ms: ?u32 = null,
 };
 
+/// Captures script eval result.
 pub const ScriptEvalResult = struct {
+    /// Stores the ok.
     ok: bool,
+    /// Stores the timed out.
     timed_out: bool,
+    /// Stores the js error.
     js_error: bool,
+    /// Stores the value.
     value: ?[]u8,
+    /// Stores the error message.
     error_message: ?[]u8,
 };
 
+/// Captures frontend call result.
 pub const FrontendCallResult = struct {
+    /// Stores the connection id.
     connection_id: usize,
+    /// Stores the result.
     result: ScriptEvalResult,
 };
 
 pub const RuntimeRequirement = runtime_requirements.RuntimeRequirement;
 
+/// Stores effective capabilities.
 pub const EffectiveCapabilities = struct {
+    /// Stores the transport if shown.
     transport_if_shown: TransportMode,
+    /// Stores the surface if shown.
     surface_if_shown: LaunchSurface,
+    /// Stores the supports native window controls.
     supports_native_window_controls: bool,
+    /// Stores the supports transparency.
     supports_transparency: bool,
+    /// Stores the supports frameless.
     supports_frameless: bool,
+    /// Stores the fallback expected.
     fallback_expected: bool,
 };
 
+/// Configures service options.
 pub const ServiceOptions = struct {
+    /// Stores the app.
     app: AppOptions = .{},
+    /// Stores the window.
     window: WindowOptions = .{},
+    /// Stores the rpc.
     rpc: RpcOptions = .{},
+    /// Stores the process signals.
     process_signals: bool = true,
 };
diff --git a/src/root/app.zig b/src/root/app.zig
index 31b1ec8..99e7780 100644
--- a/src/root/app.zig
+++ b/src/root/app.zig
@@ -3,6 +3,7 @@ const builtin = @import("builtin");
 
 const core_runtime = @import("../ported/webui.zig");
 const tls_runtime = @import("../network/tls_runtime.zig");
+const time_compat = @import("time_compat");
 const api_types = @import("api_types.zig");
 const window_mod = @import("window.zig");
 const window_state = @import("window_state.zig");
@@ -21,8 +22,11 @@ const WindowState = window_state.WindowState;
 const DiagnosticHandler = window_state.DiagnosticHandler;
 const DiagnosticCallbackState = window_state.DiagnosticCallbackState;
 
+/// Enumerates pinned struct owner values.
 pub const PinnedStructOwner = enum {
+    /// Selects `app`.
     app,
+    /// Selects `service`.
     service,
 };
 
@@ -34,12 +38,19 @@ const DiagnosticCallbackBindingMismatch = struct {
 
 /// Owns application-global configuration, windows, TLS state, and lifecycle control.
 pub const App = struct {
+    /// Stores the allocator.
     allocator: std.mem.Allocator,
+    /// Stores the options.
     options: AppOptions,
+    /// Stores the tls state.
     tls_state: tls_runtime.Runtime,
+    /// Stores the windows.
     windows: std.array_list.Managed(*WindowState),
+    /// Stores the shutdown requested.
     shutdown_requested: bool,
+    /// Tracks the next window id.
     next_window_id: usize,
+    /// Stores the diagnostic callback.
     diagnostic_callback: DiagnosticCallbackState,
 
     /// Initializes an app with explicit options.
@@ -118,11 +129,17 @@ pub const App = struct {
 
     /// Emits a diagnostic event for a specific window.
     pub fn emitDiagnostic(
+        /// Stores the self.
         self: *App,
+        /// Stores the window id.
         window_id: usize,
+        /// Stores the code.
         code: []const u8,
+        /// Stores the category.
         category: DiagnosticCategory,
+        /// Stores the severity.
         severity: DiagnosticSeverity,
+        /// Stores the message.
         message: []const u8,
     ) void {
         if (self.diagnostic_callback.handler) |handler| {
@@ -132,7 +149,7 @@ pub const App = struct {
                 .severity = severity,
                 .message = message,
                 .window_id = window_id,
-                .timestamp_ms = std.time.milliTimestamp(),
+                .timestamp_ms = time_compat.milliTimestamp(),
             };
             handler(self.diagnostic_callback.context, &diag);
         }
@@ -230,36 +247,37 @@ pub const App = struct {
         return self.newWindow(.{ .title = title });
     }
 
-    /// Starts any pending window servers and emits initial connected/capability events.
+    /// Starts any pending window servers and emits initial capability events.
     pub fn run(self: *App) !void {
         self.enforcePinnedMoveInvariant(.app);
         if (self.shutdown_requested) return;
 
         for (self.windows.items) |state| {
-            if (!state.shown or state.connected_emitted) continue;
+            if (!state.shown or state.startup_events_emitted) continue;
 
             if (state.last_html != null or state.last_file != null) {
                 try state.ensureServerStarted();
             }
 
+            state.state_mutex.lock();
+            state.dispatchPendingNativeUiTasksLocked();
+            state.state_mutex.unlock();
             if (state.isNativeWindowActive()) {
                 state.backend.pumpEvents() catch {};
             }
+            state.state_mutex.lock();
+            state.dispatchPendingNativeUiTasksLocked();
+            state.startup_events_emitted = true;
+            if (state.last_html != null or state.last_file != null) {
+                state.ensureBrowserRenderState(self.allocator, self.options) catch |err| {
+                    state.rpc_state.logf(.warn, "[webui.browser] launch failed error={s}\n", .{@errorName(err)});
+                };
+            }
+            state.state_mutex.unlock();
 
-            state.connected_emitted = true;
             for (state.capabilities()) |capability| {
                 state.emit(.window_capability, "capability", @tagName(capability));
             }
-
-            if (state.event_callback.handler) |handler| {
-                const event = Event{
-                    .window_id = state.id,
-                    .kind = .connected,
-                    .name = "connected",
-                    .payload = "",
-                };
-                handler(state.event_callback.context, &event);
-            }
         }
     }
 
@@ -275,15 +293,6 @@ pub const App = struct {
             state.state_mutex.unlock();
             state.terminateLaunchedBrowser(self.allocator);
             state.stopServer();
-            if (state.event_callback.handler) |handler| {
-                const event = Event{
-                    .window_id = state.id,
-                    .kind = .disconnected,
-                    .name = "disconnected",
-                    .payload = "",
-                };
-                handler(state.event_callback.context, &event);
-            }
         }
     }
 };
diff --git a/src/root/logging.zig b/src/root/logging.zig
index 93ce836..1ee7c24 100644
--- a/src/root/logging.zig
+++ b/src/root/logging.zig
@@ -1,16 +1,24 @@
 const std = @import("std");
 
+/// Enumerates level values.
 pub const Level = enum {
+    /// Selects `debug`.
     debug,
+    /// Selects `info`.
     info,
+    /// Selects `warn`.
     warn,
+    /// Selects `err`.
     err,
 };
 
 pub const Handler = *const fn (context: ?*anyopaque, level: Level, message: []const u8) void;
 
+/// Stores sink.
 pub const Sink = struct {
+    /// Stores the handler.
     handler: ?Handler = null,
+    /// Stores the context.
     context: ?*anyopaque = null,
 };
 
diff --git a/src/root/net_io.zig b/src/root/net_io.zig
index 9a5c767..436d5f5 100644
--- a/src/root/net_io.zig
+++ b/src/root/net_io.zig
@@ -1,13 +1,23 @@
 const std = @import("std");
-const builtin = @import("builtin");
-const websocket = @import("websocket");
+const zhttp_request = @import("zhttp_request");
+const time_compat = @import("time_compat");
+const io_compat = @import("io_compat");
 
+/// Stores http request.
 pub const HttpRequest = struct {
+    /// Stores the raw.
     raw: []u8,
+    /// Stores the method.
     method: []const u8,
-    path: []const u8,
+    /// Stores the target.
+    target: []const u8,
+    /// Stores the query.
+    query: []const u8,
+    /// Stores the headers.
     headers: []const u8,
+    /// Stores the body.
     body: []const u8,
+    /// Stores the remainder.
     remainder: []const u8,
 };
 
@@ -19,62 +29,83 @@ const WsInboundType = enum {
     close,
 };
 
+/// Stores ws inbound frame.
 pub const WsInboundFrame = struct {
+    /// Stores the kind.
     kind: WsInboundType,
+    /// Stores the payload.
     payload: []u8,
 };
 
+/// Enumerates ws outbound opcode values.
+pub const WsOutboundOpcode = enum(u8) {
+    /// Selects `continuation`.
+    continuation = 0x0,
+    /// Selects `text`.
+    text = 0x1,
+    /// Selects `binary`.
+    binary = 0x2,
+    /// Selects `close`.
+    close = 0x8,
+    /// Selects `ping`.
+    ping = 0x9,
+    /// Selects `pong`.
+    pong = 0xA,
+};
+
+fn readFromStream(stream: std.Io.net.Stream, buffer: []u8) !usize {
+    var read_buf: [0]u8 = .{};
+    var reader = stream.reader(io_compat.io, &read_buf);
+    var vec = [_][]u8{buffer};
+    return reader.interface.readVec(&vec) catch |err| switch (err) {
+        error.EndOfStream => 0,
+        error.ReadFailed => return reader.err orelse error.Closed,
+    };
+}
+
 fn readConn(conn: anytype, buffer: []u8) !usize {
     const Conn = @TypeOf(conn);
-    if (builtin.os.tag == .windows) {
-        if (Conn == std.net.Stream) {
-            return std.posix.recv(conn.handle, buffer, 0);
-        }
-        if (Conn == *std.net.Stream) {
-            return std.posix.recv(conn.handle, buffer, 0);
-        }
-    }
-    if (Conn == std.net.Stream) {
-        return conn.read(buffer);
+    if (Conn == std.Io.net.Stream) {
+        return readFromStream(conn, buffer);
     }
-    if (Conn == *std.net.Stream) {
-        return conn.read(buffer);
+    if (Conn == *std.Io.net.Stream) {
+        return readFromStream(conn.*, buffer);
     }
     return conn.read(buffer);
 }
 
 fn writeConnAll(conn: anytype, bytes: []const u8) !void {
     const Conn = @TypeOf(conn);
-    if (builtin.os.tag == .windows) {
-        if (Conn == std.net.Stream) {
-            return sendAllWindows(conn.handle, bytes);
-        }
-        if (Conn == *std.net.Stream) {
-            return sendAllWindows(conn.handle, bytes);
-        }
-    }
-    if (Conn == std.net.Stream) {
-        return conn.writeAll(bytes);
+    if (Conn == std.Io.net.Stream) {
+        return sendAllStream(conn, bytes);
     }
-    if (Conn == *std.net.Stream) {
-        return conn.writeAll(bytes);
+    if (Conn == *std.Io.net.Stream) {
+        return sendAllStream(conn.*, bytes);
     }
     return conn.writeAll(bytes);
 }
 
-fn sendAllWindows(socket: std.posix.socket_t, bytes: []const u8) !void {
-    var offset: usize = 0;
-    while (offset < bytes.len) {
-        const n = std.posix.send(socket, bytes[offset..], 0) catch |err| switch (err) {
-            error.WouldBlock => {
-                std.Thread.sleep(std.time.ns_per_ms);
-                continue;
-            },
-            else => return err,
-        };
-        if (n == 0) return error.Closed;
-        offset += n;
-    }
+fn sendAllStream(stream: std.Io.net.Stream, bytes: []const u8) !void {
+    var write_buf: [1024]u8 = undefined;
+    var writer = stream.writer(io_compat.io, &write_buf);
+    writer.interface.writeAll(bytes) catch |err| {
+        if (err == error.WriteFailed) return writer.err orelse error.Closed;
+        return err;
+    };
+    writer.interface.flush() catch |err| {
+        if (err == error.WriteFailed) return writer.err orelse error.Closed;
+        return err;
+    };
+}
+
+/// Writes all bytes to a plain TCP stream.
+pub fn writeAllToStream(stream: std.Io.net.Stream, bytes: []const u8) !void {
+    try sendAllStream(stream, bytes);
+}
+
+/// Reads bytes from a plain TCP stream into `buffer`.
+pub fn readFromPlainStream(stream: std.Io.net.Stream, buffer: []u8) !usize {
+    return readFromStream(stream, buffer);
 }
 
 fn readConnExact(conn: anytype, out: []u8) !void {
@@ -83,7 +114,7 @@ fn readConnExact(conn: anytype, out: []u8) !void {
         const n = readConn(conn, out[offset..]) catch |err| {
             const err_name = @errorName(err);
             if (std.mem.eql(u8, err_name, "WouldBlock")) {
-                std.Thread.sleep(std.time.ns_per_ms);
+                time_compat.sleep(std.time.ns_per_ms);
                 continue;
             }
             if (std.mem.eql(u8, err_name, "ConnectionResetByPeer") or
@@ -113,6 +144,11 @@ fn readConnExactBuffered(conn: anytype, prebuffer: *[]const u8, out: []u8) !void
     }
 }
 
+/// Reads exactly `out.len` bytes from a plain stream, consuming any bytes already present in `prebuffer` first.
+pub fn readExactBufferedFromStream(stream: std.Io.net.Stream, prebuffer: *[]const u8, out: []u8) !void {
+    try readConnExactBuffered(stream, prebuffer, out);
+}
+
 fn decodeWsOpcode(byte: u8) !WsInboundType {
     return switch (byte & 0x0F) {
         0x1 => .text,
@@ -189,7 +225,7 @@ pub fn readWsInboundFrameAllocBufferedAny(
 }
 
 /// Reads a single inbound websocket frame from a plain TCP stream.
-pub fn readWsInboundFrameAlloc(allocator: std.mem.Allocator, stream: std.net.Stream, max_payload_size: usize) !WsInboundFrame {
+pub fn readWsInboundFrameAlloc(allocator: std.mem.Allocator, stream: std.Io.net.Stream, max_payload_size: usize) !WsInboundFrame {
     return readWsInboundFrameAllocAny(allocator, stream, max_payload_size);
 }
 
@@ -228,19 +264,18 @@ pub fn writeWebSocketHandshakeResponseAny(conn: anytype, sec_key: []const u8) !v
 }
 
 /// Writes the websocket upgrade response to a plain TCP stream.
-pub fn writeWebSocketHandshakeResponse(stream: std.net.Stream, sec_key: []const u8) !void {
+pub fn writeWebSocketHandshakeResponse(stream: std.Io.net.Stream, sec_key: []const u8) !void {
     try writeWebSocketHandshakeResponseAny(stream, sec_key);
 }
 
-/// Returns the request path without any query string.
-pub fn pathWithoutQuery(path: []const u8) []const u8 {
-    return if (std.mem.indexOfScalar(u8, path, '?')) |q| path[0..q] else path;
+/// Returns the request path component from a raw request target.
+pub fn pathWithoutQuery(target: []const u8) []const u8 {
+    return if (std.mem.indexOfScalar(u8, target, '?')) |q| target[0..q] else target;
 }
 
-/// Extracts the websocket `client_id` query parameter or returns `default_client_token`.
-pub fn wsClientTokenFromUrl(url: []const u8, default_client_token: []const u8) []const u8 {
-    const query_start = std.mem.indexOfScalar(u8, url, '?') orelse return default_client_token;
-    var pair_it = std.mem.splitScalar(u8, url[query_start + 1 ..], '&');
+/// Extracts websocket `client_id` from a query string or returns `default_client_token`.
+pub fn wsClientTokenFromQuery(query: []const u8, default_client_token: []const u8) []const u8 {
+    var pair_it = std.mem.splitScalar(u8, query, '&');
     while (pair_it.next()) |pair| {
         if (pair.len == 0) continue;
         const eq = std.mem.indexOfScalar(u8, pair, '=') orelse continue;
@@ -279,7 +314,7 @@ pub fn readHttpRequestAny(allocator: std.mem.Allocator, conn: anytype) !HttpRequ
         const read_n = readConn(conn, &scratch) catch |err| {
             const err_name = @errorName(err);
             if (std.mem.eql(u8, err_name, "WouldBlock")) {
-                std.Thread.sleep(std.time.ns_per_ms);
+                time_compat.sleep(std.time.ns_per_ms);
                 continue;
             }
             if (std.mem.eql(u8, err_name, "ConnectionResetByPeer") or
@@ -312,11 +347,24 @@ pub fn readHttpRequestAny(allocator: std.mem.Allocator, conn: anytype) !HttpRequ
 
     const end_idx = header_end orelse return error.InvalidHttpRequest;
     const first_line_end = std.mem.indexOf(u8, raw, "\r\n") orelse return error.InvalidHttpRequest;
-
-    const line = raw[0..first_line_end];
-    var line_it = std.mem.splitScalar(u8, line, ' ');
-    const method = line_it.next() orelse return error.InvalidHttpRequest;
-    const path = line_it.next() orelse return error.InvalidHttpRequest;
+    var request_line_reader = std.Io.Reader.fixed(raw[0 .. first_line_end + 2]);
+    const parsed_line = zhttp_request.parseRequestLineBorrowed(&request_line_reader, 8 * 1024) catch return error.InvalidHttpRequest;
+    const method = parsed_line.method;
+    const path_start = @intFromPtr(parsed_line.path.ptr) - @intFromPtr(raw.ptr);
+    const path_end = path_start + parsed_line.path.len;
+    if (path_end > raw.len) return error.InvalidHttpRequest;
+    var target_end = path_end;
+    var query: []const u8 = "";
+    if (parsed_line.query.len != 0) {
+        const query_start = @intFromPtr(parsed_line.query.ptr) - @intFromPtr(raw.ptr);
+        const query_end = query_start + parsed_line.query.len;
+        if (query_start <= path_end or query_end > raw.len or raw[query_start - 1] != '?') {
+            return error.InvalidHttpRequest;
+        }
+        target_end = query_end;
+        query = raw[query_start..query_end];
+    }
+    const target = raw[path_start..target_end];
 
     const body_end = end_idx + content_length;
     if (body_end > raw.len) return error.InvalidHttpRequest;
@@ -327,7 +375,8 @@ pub fn readHttpRequestAny(allocator: std.mem.Allocator, conn: anytype) !HttpRequ
     return .{
         .raw = raw,
         .method = method,
-        .path = path,
+        .target = target,
+        .query = query,
         .headers = headers,
         .body = raw[end_idx..body_end],
         .remainder = raw[body_end..],
@@ -335,7 +384,7 @@ pub fn readHttpRequestAny(allocator: std.mem.Allocator, conn: anytype) !HttpRequ
 }
 
 /// Reads and parses a complete HTTP request from a plain TCP stream.
-pub fn readHttpRequest(allocator: std.mem.Allocator, stream: std.net.Stream) !HttpRequest {
+pub fn readHttpRequest(allocator: std.mem.Allocator, stream: std.Io.net.Stream) !HttpRequest {
     return readHttpRequestAny(allocator, stream);
 }
 
@@ -377,7 +426,7 @@ pub fn writeHttpResponseAny(conn: anytype, status: u16, content_type: []const u8
 }
 
 /// Writes a complete HTTP response to a plain TCP stream.
-pub fn writeHttpResponse(stream: std.net.Stream, status: u16, content_type: []const u8, body: []const u8) !void {
+pub fn writeHttpResponse(stream: std.Io.net.Stream, status: u16, content_type: []const u8, body: []const u8) !void {
     return writeHttpResponseAny(stream, status, content_type, body);
 }
 
@@ -393,10 +442,35 @@ pub fn writeHttpRedirectAny(conn: anytype, location: []const u8) !void {
 }
 
 /// Writes a websocket frame to any supported transport.
-pub fn writeWsFrameAny(conn: anytype, opcode: websocket.OpCode, payload: []const u8) !void {
+pub fn writeWsFrameAny(conn: anytype, opcode: WsOutboundOpcode, payload: []const u8) !void {
     var header_buf: [10]u8 = undefined;
-    const header = websocket.proto.writeFrameHeader(&header_buf, opcode, payload.len, false);
-    try writeConnAll(conn, header);
+    const opcode_u8: u8 = @intFromEnum(opcode);
+    header_buf[0] = 0x80 | (opcode_u8 & 0x0F);
+
+    var header_len: usize = 2;
+    if (payload.len <= 125) {
+        header_buf[1] = @as(u8, @intCast(payload.len));
+    } else if (payload.len <= std.math.maxInt(u16)) {
+        header_buf[1] = 126;
+        const payload_u16: u16 = @intCast(payload.len);
+        header_buf[2] = @as(u8, @intCast(payload_u16 >> 8));
+        header_buf[3] = @as(u8, @intCast(payload_u16 & 0xFF));
+        header_len = 4;
+    } else {
+        header_buf[1] = 127;
+        const payload_u64: u64 = @intCast(payload.len);
+        header_buf[2] = @as(u8, @intCast((payload_u64 >> 56) & 0xFF));
+        header_buf[3] = @as(u8, @intCast((payload_u64 >> 48) & 0xFF));
+        header_buf[4] = @as(u8, @intCast((payload_u64 >> 40) & 0xFF));
+        header_buf[5] = @as(u8, @intCast((payload_u64 >> 32) & 0xFF));
+        header_buf[6] = @as(u8, @intCast((payload_u64 >> 24) & 0xFF));
+        header_buf[7] = @as(u8, @intCast((payload_u64 >> 16) & 0xFF));
+        header_buf[8] = @as(u8, @intCast((payload_u64 >> 8) & 0xFF));
+        header_buf[9] = @as(u8, @intCast(payload_u64 & 0xFF));
+        header_len = 10;
+    }
+
+    try writeConnAll(conn, header_buf[0..header_len]);
     if (payload.len > 0) {
         try writeConnAll(conn, payload);
     }
@@ -416,36 +490,23 @@ pub fn contentTypeForPath(path: []const u8) []const u8 {
 }
 
 /// Reads the entire stream into memory up to `max_bytes`.
-pub fn readAllFromStream(allocator: std.mem.Allocator, stream: std.net.Stream, max_bytes: usize) ![]u8 {
+pub fn readAllFromStream(allocator: std.mem.Allocator, stream: std.Io.net.Stream, max_bytes: usize) ![]u8 {
     var out = std.array_list.Managed(u8).init(allocator);
     errdefer out.deinit();
 
     var scratch: [4096]u8 = undefined;
     while (true) {
-        const n = if (builtin.os.tag == .windows)
-            std.posix.recv(stream.handle, &scratch, 0) catch |err| switch (err) {
-                error.WouldBlock => {
-                    std.Thread.sleep(std.time.ns_per_ms);
-                    continue;
-                },
-                error.ConnectionResetByPeer,
-                error.ConnectionTimedOut,
-                error.SocketNotConnected,
-                => break,
-                else => return err,
+        const n = readConn(stream, &scratch) catch |err| {
+            const err_name = @errorName(err);
+            if (std.mem.eql(u8, err_name, "ConnectionResetByPeer") or
+                std.mem.eql(u8, err_name, "ConnectionTimedOut") or
+                std.mem.eql(u8, err_name, "SocketNotConnected") or
+                std.mem.eql(u8, err_name, "EndOfStream"))
+            {
+                break;
             }
-        else
-            stream.read(&scratch) catch |err| switch (err) {
-                error.WouldBlock => {
-                    std.Thread.sleep(std.time.ns_per_ms);
-                    continue;
-                },
-                error.ConnectionResetByPeer,
-                error.ConnectionTimedOut,
-                error.SocketNotConnected,
-                => break,
-                else => return err,
-            };
+            return err;
+        };
         if (n == 0) break;
         if (out.items.len + n > max_bytes) return error.ResponseTooLarge;
         try out.appendSlice(scratch[0..n]);
@@ -474,9 +535,9 @@ pub fn httpRoundTripWithHeaders(
     body: ?[]const u8,
     extra_headers: []const []const u8,
 ) ![]u8 {
-    const address = try std.net.Address.parseIp4("127.0.0.1", port);
-    const stream = try std.net.tcpConnectToAddress(address);
-    defer stream.close();
+    const address = try std.Io.net.IpAddress.parseIp4("127.0.0.1", port);
+    const stream = try std.Io.net.IpAddress.connect(&address, io_compat.io, .{ .mode = .stream });
+    defer stream.close(io_compat.io);
 
     var extra = std.array_list.Managed(u8).init(allocator);
     defer extra.deinit();
@@ -504,22 +565,26 @@ pub fn httpRoundTripWithHeaders(
 }
 
 /// Reads just the HTTP header section from a stream.
-pub fn readHttpHeadersFromStream(allocator: std.mem.Allocator, stream: std.net.Stream, max_bytes: usize) ![]u8 {
+pub fn readHttpHeadersFromStream(allocator: std.mem.Allocator, stream: std.Io.net.Stream, max_bytes: usize) ![]u8 {
     var out = std.array_list.Managed(u8).init(allocator);
     errdefer out.deinit();
 
     var scratch: [512]u8 = undefined;
     while (out.items.len < max_bytes) {
-        const n = std.posix.recv(stream.handle, &scratch, 0) catch |err| switch (err) {
-            error.WouldBlock => {
-                std.Thread.sleep(std.time.ns_per_ms);
+        const n = readConn(stream, &scratch) catch |err| {
+            const err_name = @errorName(err);
+            if (std.mem.eql(u8, err_name, "WouldBlock")) {
+                time_compat.sleep(std.time.ns_per_ms);
                 continue;
-            },
-            error.ConnectionResetByPeer,
-            error.ConnectionTimedOut,
-            error.SocketNotConnected,
-            => break,
-            else => return err,
+            }
+            if (std.mem.eql(u8, err_name, "ConnectionResetByPeer") or
+                std.mem.eql(u8, err_name, "ConnectionTimedOut") or
+                std.mem.eql(u8, err_name, "SocketNotConnected") or
+                std.mem.eql(u8, err_name, "EndOfStream"))
+            {
+                break;
+            }
+            return err;
         };
         if (n == 0) break;
         if (out.items.len + n > max_bytes) return error.ResponseTooLarge;
diff --git a/src/root/process_signals.zig b/src/root/process_signals.zig
index 85f37ff..8f8e1e5 100644
--- a/src/root/process_signals.zig
+++ b/src/root/process_signals.zig
@@ -1,5 +1,16 @@
 const std = @import("std");
 const builtin = @import("builtin");
+const win = std.os.windows;
+const CTRL_C_EVENT: win.DWORD = 0;
+const CTRL_BREAK_EVENT: win.DWORD = 1;
+const CTRL_CLOSE_EVENT: win.DWORD = 2;
+const CTRL_LOGOFF_EVENT: win.DWORD = 5;
+const CTRL_SHUTDOWN_EVENT: win.DWORD = 6;
+
+extern "kernel32" fn SetConsoleCtrlHandler(
+    ?*const fn (win.DWORD) callconv(.winapi) win.BOOL,
+    win.BOOL,
+) callconv(.winapi) win.BOOL;
 
 var installed = std.atomic.Value(bool).init(false);
 var caught_signal = std.atomic.Value(i32).init(0);
@@ -17,7 +28,7 @@ fn installPosix() void {
     installPosixSignal(std.posix.SIG.QUIT);
 }
 
-fn installPosixSignal(sig: u8) void {
+fn installPosixSignal(sig: std.posix.SIG) void {
     var action = std.posix.Sigaction{
         .handler = .{ .handler = onPosixSignal },
         .mask = std.posix.sigemptyset(),
@@ -26,24 +37,24 @@ fn installPosixSignal(sig: u8) void {
     std.posix.sigaction(sig, &action, null);
 }
 
-fn onPosixSignal(sig: i32) callconv(.c) void {
-    recordSignal(sig);
+fn onPosixSignal(sig: std.posix.SIG) callconv(.c) void {
+    recordSignal(@intCast(@intFromEnum(sig)));
 }
 
 fn installWindows() void {
-    std.os.windows.SetConsoleCtrlHandler(onWindowsCtrl, true) catch {};
+    _ = SetConsoleCtrlHandler(onWindowsCtrl, win.BOOL.TRUE);
 }
 
 fn onWindowsCtrl(ctrl_type: std.os.windows.DWORD) callconv(.winapi) std.os.windows.BOOL {
     switch (ctrl_type) {
-        std.os.windows.CTRL_C_EVENT => recordSignal(2),
-        std.os.windows.CTRL_BREAK_EVENT => recordSignal(21),
-        std.os.windows.CTRL_CLOSE_EVENT => recordSignal(15),
-        std.os.windows.CTRL_LOGOFF_EVENT => recordSignal(1),
-        std.os.windows.CTRL_SHUTDOWN_EVENT => recordSignal(15),
-        else => return std.os.windows.FALSE,
+        CTRL_C_EVENT => recordSignal(2),
+        CTRL_BREAK_EVENT => recordSignal(21),
+        CTRL_CLOSE_EVENT => recordSignal(15),
+        CTRL_LOGOFF_EVENT => recordSignal(1),
+        CTRL_SHUTDOWN_EVENT => recordSignal(15),
+        else => return std.os.windows.BOOL.FALSE,
     }
-    return std.os.windows.TRUE;
+    return std.os.windows.BOOL.TRUE;
 }
 
 /// Installs process signal handlers once for the current platform.
diff --git a/src/root/rpc_reflect.zig b/src/root/rpc_reflect.zig
index b76dbdc..5fc7d26 100644
--- a/src/root/rpc_reflect.zig
+++ b/src/root/rpc_reflect.zig
@@ -9,7 +9,7 @@ pub fn buildTsArgSignature(allocator: std.mem.Allocator, comptime params: anytyp
     inline for (params, 0..) |param, idx| {
         if (idx != 0) try out.appendSlice(", ");
         const param_type = param.type orelse return error.InvalidRpcParamType;
-        try out.writer().print("arg{d}: {s}", .{ idx, tsTypeNameForType(param_type) });
+        try out.print("arg{d}: {s}", .{ idx, tsTypeNameForType(param_type) });
     }
 
     return out.toOwnedSlice();
diff --git a/src/root/rpc_registry.zig b/src/root/rpc_registry.zig
index 7e8a57e..1d43f17 100644
--- a/src/root/rpc_registry.zig
+++ b/src/root/rpc_registry.zig
@@ -1,4 +1,5 @@
 const std = @import("std");
+const io_compat = @import("io_compat");
 
 const bridge_template = @import("../bridge/template.zig");
 const api_types = @import("api_types.zig");
@@ -17,7 +18,9 @@ const makeInvoker = rpc_reflect.makeInvoker;
 
 /// Registers Zig RPC functions and exposes generated JS/TypeScript bridge artifacts.
 pub const RpcRegistry = struct {
+    /// Stores the allocator.
     allocator: std.mem.Allocator,
+    /// Stores the state.
     state: *State,
 
     /// Registers every public function in `RpcStruct` and refreshes the generated bridge artifacts.
@@ -78,11 +81,13 @@ pub const RpcRegistry = struct {
     /// Writes the generated JavaScript client bridge to `output_path`.
     pub fn writeGeneratedClientScript(self: RpcRegistry, output_path: []const u8) !void {
         if (std.fs.path.dirname(output_path)) |dir_name| {
-            try std.fs.cwd().makePath(dir_name);
+            try std.Io.Dir.cwd().createDirPath(io_compat.io, dir_name);
         }
-        const file = try std.fs.cwd().createFile(output_path, .{ .truncate = true });
-        defer file.close();
-        try file.writeAll(self.generatedClientScript());
+        try std.Io.Dir.cwd().writeFile(io_compat.io, .{
+            .sub_path = output_path,
+            .data = self.generatedClientScript(),
+            .flags = .{ .truncate = true },
+        });
     }
 
     /// Returns the generated TypeScript declarations for the currently registered RPC surface.
@@ -101,11 +106,13 @@ pub const RpcRegistry = struct {
     /// Writes the generated TypeScript declarations to `output_path`.
     pub fn writeGeneratedTypeScriptDeclarations(self: RpcRegistry, output_path: []const u8) !void {
         if (std.fs.path.dirname(output_path)) |dir_name| {
-            try std.fs.cwd().makePath(dir_name);
+            try std.Io.Dir.cwd().createDirPath(io_compat.io, dir_name);
         }
-        const file = try std.fs.cwd().createFile(output_path, .{ .truncate = true });
-        defer file.close();
-        try file.writeAll(self.generatedTypeScriptDeclarations());
+        try std.Io.Dir.cwd().writeFile(io_compat.io, .{
+            .sub_path = output_path,
+            .data = self.generatedTypeScriptDeclarations(),
+            .flags = .{ .truncate = true },
+        });
     }
 
     /// Rebuilds the generated JavaScript and TypeScript bridge artifacts from the registered RPC handlers.
diff --git a/src/root/rpc_runtime.zig b/src/root/rpc_runtime.zig
index f530177..39cb676 100644
--- a/src/root/rpc_runtime.zig
+++ b/src/root/rpc_runtime.zig
@@ -2,12 +2,19 @@ const std = @import("std");
 const bridge_template = @import("../bridge/template.zig");
 const api_types = @import("api_types.zig");
 const logging = @import("logging.zig");
+const thread_compat = @import("thread_compat");
 
+/// Stores handler entry.
 pub const HandlerEntry = struct {
+    /// Stores the name.
     name: []u8,
+    /// Stores the arity.
     arity: usize,
+    /// Stores the invoker.
     invoker: api_types.RpcInvokeFn,
+    /// Stores the ts arg signature.
     ts_arg_signature: []u8,
+    /// Stores the ts return type.
     ts_return_type: []u8,
 };
 
@@ -17,8 +24,8 @@ const Task = struct {
     done: bool = false,
     result_json: ?[]u8 = null,
     err: ?anyerror = null,
-    mutex: std.Thread.Mutex = .{},
-    cond: std.Thread.Condition = .{},
+    mutex: thread_compat.Mutex = .{},
+    cond: thread_compat.Condition = .{},
 
     fn init(allocator: std.mem.Allocator, payload_json: []const u8) !*Task {
         const task = try allocator.create(Task);
@@ -36,31 +43,54 @@ const Task = struct {
     }
 };
 
+/// Stores state.
 pub const State = struct {
+    /// Stores log config.
     pub const LogConfig = struct {
+        /// Stores the enabled.
         enabled: bool = false,
+        /// Stores the sink.
         sink: logging.Sink = .{},
     };
 
+    /// Stores the handlers.
     handlers: std.array_list.Managed(HandlerEntry),
+    /// Stores the generated script.
     generated_script: []const u8,
+    /// Stores the generated typescript.
     generated_typescript: []const u8,
+    /// Stores the generated script owned.
     generated_script_owned: ?[]u8,
+    /// Stores the generated typescript owned.
     generated_typescript_owned: ?[]u8,
+    /// Stores the bridge options.
     bridge_options: api_types.BridgeOptions,
+    /// Stores the dispatcher mode.
     dispatcher_mode: api_types.DispatcherMode,
+    /// Stores the custom dispatcher.
     custom_dispatcher: ?api_types.CustomDispatcher,
+    /// Stores the custom context.
     custom_context: ?*anyopaque,
+    /// Stores the threaded poll interval ns.
     threaded_poll_interval_ns: u64,
-    invoke_mutex: std.Thread.Mutex,
-
-    queue_mutex: std.Thread.Mutex,
-    queue_cond: std.Thread.Condition,
+    /// Coordinates access to the invoke.
+    invoke_mutex: thread_compat.Mutex,
+
+    /// Coordinates access to the queue.
+    queue_mutex: thread_compat.Mutex,
+    /// Coordinates access to the queue.
+    queue_cond: thread_compat.Condition,
+    /// Stores the queue.
     queue: std.array_list.Managed(*Task),
+    /// Owns the worker thread.
     worker_thread: ?std.Thread,
+    /// Stores the worker stop.
     worker_stop: std.atomic.Value(bool),
-    worker_lifecycle_mutex: std.Thread.Mutex,
+    /// Coordinates access to the worker lifecycle.
+    worker_lifecycle_mutex: thread_compat.Mutex,
+    /// Whether log enabled.
     log_enabled: bool,
+    /// Stores the log sink.
     log_sink: logging.Sink,
 
     /// Initializes RPC runtime state with the requested logging configuration.
@@ -117,12 +147,19 @@ pub const State = struct {
 
     /// Registers or replaces a typed RPC handler entry.
     pub fn addFunction(
+        /// Stores the self.
         self: *State,
+        /// Stores the allocator.
         allocator: std.mem.Allocator,
+        /// Stores the function name.
         function_name: []const u8,
+        /// Stores the arity.
         arity: usize,
+        /// Stores the invoker.
         invoker: api_types.RpcInvokeFn,
+        /// Stores the ts arg signature.
         ts_arg_signature: []const u8,
+        /// Stores the ts return type.
         ts_return_type: []const u8,
     ) !void {
         for (self.handlers.items) |*existing| {
@@ -153,9 +190,13 @@ pub const State = struct {
 
     /// Replaces the generated bridge artifacts and frees the previously owned copies.
     pub fn replaceGeneratedArtifacts(
+        /// Stores the self.
         self: *State,
+        /// Stores the allocator.
         allocator: std.mem.Allocator,
+        /// Stores the generated script.
         generated_script: ?[]u8,
+        /// Stores the generated typescript.
         generated_typescript: ?[]u8,
     ) void {
         if (self.generated_script_owned) |owned| allocator.free(owned);
@@ -175,9 +216,13 @@ pub const State = struct {
     }
 
     fn invokeSync(
+        /// Stores the self.
         self: *State,
+        /// Stores the allocator.
         allocator: std.mem.Allocator,
+        /// Stores the function name.
         function_name: []const u8,
+        /// Stores the args.
         args: []const std.json.Value,
     ) ![]u8 {
         const handler = self.findHandler(function_name) orelse return error.UnknownRpcFunction;
@@ -340,10 +385,10 @@ pub const State = struct {
 };
 
 test "threaded rpc invalid payload does not leak task state" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer {
         const status = gpa.deinit();
-        std.testing.expect(status == .ok) catch unreachable;
+        if (status != .ok) @panic("threaded rpc invalid payload leaked memory");
     }
 
     var state = State.init(gpa.allocator(), .{});
diff --git a/src/root/runtime_requirements.zig b/src/root/runtime_requirements.zig
index 6cef71e..a6fa3d0 100644
--- a/src/root/runtime_requirements.zig
+++ b/src/root/runtime_requirements.zig
@@ -14,19 +14,31 @@ const macos_webview_host = if (builtin.os.tag == .macos)
 else
     struct {};
 
+/// Stores runtime requirement.
 pub const RuntimeRequirement = struct {
+    /// Stores the name.
     name: []const u8,
+    /// Stores the required.
     required: bool,
+    /// Stores the available.
     available: bool,
+    /// Stores the details.
     details: ?[]const u8 = null,
 };
 
+/// Configures list options.
 pub const ListOptions = struct {
+    /// Stores the uses native webview.
     uses_native_webview: bool,
+    /// Stores the uses managed browser.
     uses_managed_browser: bool,
+    /// Stores the uses web url.
     uses_web_url: bool,
+    /// Stores the app mode required.
     app_mode_required: bool,
+    /// Stores the native backend available.
     native_backend_available: bool,
+    /// Stores the linux webview target.
     linux_webview_target: api_types.LinuxWebViewTarget = .webview,
 };
 
diff --git a/src/root/server_routes.zig b/src/root/server_routes.zig
index 7e7d938..b25f231 100644
--- a/src/root/server_routes.zig
+++ b/src/root/server_routes.zig
@@ -1,4 +1,5 @@
 const std = @import("std");
+const io_compat = @import("io_compat");
 
 const net_io = @import("net_io.zig");
 const api_types = @import("api_types.zig");
@@ -20,7 +21,7 @@ pub fn handleConnection(
     const request = try net_io.readHttpRequestAny(allocator, conn);
     defer allocator.free(request.raw);
 
-    const path_only = net_io.pathWithoutQuery(request.path);
+    const path_only = net_io.pathWithoutQuery(request.target);
     switch (try handleWebSocketUpgradeRoute(state, conn, request, path_only, default_client_token)) {
         .not_handled => {},
         .handled => return false,
@@ -41,7 +42,7 @@ pub fn handleConnection(
 
 fn closeOwnedTransport(_: anytype, transport: anytype) void {
     switch (@TypeOf(transport)) {
-        std.net.Stream => transport.close(),
+        std.Io.net.Stream => transport.close(io_compat.io),
         else => {
             transport.close();
             std.heap.page_allocator.destroy(transport);
@@ -60,11 +61,16 @@ fn wsConnectionThreadMain(
     defer {
         if (initial_remainder.len != 0) state.allocator.free(initial_remainder);
 
+        var last_frontend_disconnect = false;
         state.state_mutex.lock();
         if (state.unregisterWsConnectionLocked(connection_id, generation)) {
+            last_frontend_disconnect = !state.frontend_connected;
             state.noteWsDisconnectLocked("websocket-disconnected");
         }
         state.state_mutex.unlock();
+        if (last_frontend_disconnect) {
+            state.emit(.disconnected, "disconnected", "");
+        }
 
         state.connection_mutex.lock();
         if (state.active_ws_workers > 0) state.active_ws_workers -= 1;
@@ -151,22 +157,28 @@ fn handleWebSocketUpgradeRoute(
 
     try net_io.writeWebSocketHandshakeResponseAny(conn, sec_key);
 
-    const token = net_io.wsClientTokenFromUrl(request.path, default_client_token);
+    const token = net_io.wsClientTokenFromQuery(request.query, default_client_token);
     const initial_remainder = try state.allocator.dupe(u8, request.remainder);
     errdefer state.allocator.free(initial_remainder);
     var connection_id: usize = 0;
     var generation: u64 = 0;
+    var first_frontend_connection = false;
     state.state_mutex.lock();
     errdefer state.state_mutex.unlock();
     {
         const client_ref = try state.findOrCreateClientSessionLocked(token);
         connection_id = client_ref.connection_id;
-        generation = try state.registerWsConnectionLocked(connection_id, conn);
+        const registration = try state.registerWsConnectionLocked(connection_id, conn);
+        generation = registration.generation;
+        first_frontend_connection = registration.first_connection;
     }
     state.state_mutex.unlock();
 
     state.rpc_state.logf(.info, "[webui.ws] connected connection_id={d}\n", .{connection_id});
     state.emitDiagnostic("websocket.connected", .websocket, .info, "WebSocket client connected");
+    if (first_frontend_connection) {
+        state.emit(.connected, "connected", "");
+    }
 
     state.connection_mutex.lock();
     state.active_ws_workers += 1;
@@ -178,11 +190,16 @@ fn handleWebSocketUpgradeRoute(
         state.connection_cond.broadcast();
         state.connection_mutex.unlock();
 
+        var last_frontend_disconnect = false;
         state.state_mutex.lock();
         if (state.unregisterWsConnectionLocked(connection_id, generation)) {
+            last_frontend_disconnect = !state.frontend_connected;
             state.noteWsDisconnectLocked("websocket-spawn-failed");
         }
         state.state_mutex.unlock();
+        if (last_frontend_disconnect) {
+            state.emit(.disconnected, "disconnected", "");
+        }
         state.allocator.free(initial_remainder);
         return err;
     };
@@ -308,9 +325,7 @@ fn handleWindowControlRoute(
 
     state.rpc_state.logf(.debug, "[webui.window] control cmd={s}\n", .{@tagName(cmd)});
 
-    state.state_mutex.lock();
     const result = state.control(cmd) catch |err| {
-        state.state_mutex.unlock();
         state.rpc_state.logf(.warn, "[webui.window] control error={s}\n", .{@errorName(err)});
         const status: u16 = switch (err) {
             error.UnsupportedWindowControl,
@@ -321,7 +336,6 @@ fn handleWindowControlRoute(
         try net_io.writeHttpResponseAny(conn, status, "application/json; charset=utf-8", "");
         return true;
     };
-    state.state_mutex.unlock();
 
     state.rpc_state.logf(.debug, "[webui.window] control result success={any} emulation={s} closed={any} warning={s}\n", .{
         result.success,
@@ -371,22 +385,20 @@ fn handleWindowStyleRoute(
     };
     defer parsed.deinit();
 
-    state.state_mutex.lock();
-    const payload = blk: {
-        state.applyStyle(allocator, parsed.value) catch |err| {
-            state.state_mutex.unlock();
-            state.rpc_state.logf(.warn, "[webui.window] style error={s}\n", .{@errorName(err)});
-            const status: u16 = switch (err) {
-                error.UnsupportedWindowStyle => 422,
-                else => 500,
-            };
-            try net_io.writeHttpResponseAny(conn, status, "application/json; charset=utf-8", "");
-            return true;
-        };
-        break :blk std.json.Stringify.valueAlloc(allocator, state.current_style, .{}) catch |err| {
-            state.state_mutex.unlock();
-            return err;
+    state.applyStyle(allocator, parsed.value) catch |err| {
+        state.rpc_state.logf(.warn, "[webui.window] style error={s}\n", .{@errorName(err)});
+        const status: u16 = switch (err) {
+            error.UnsupportedWindowStyle => 422,
+            else => 500,
         };
+        try net_io.writeHttpResponseAny(conn, status, "application/json; charset=utf-8", "");
+        return true;
+    };
+
+    state.state_mutex.lock();
+    const payload = std.json.Stringify.valueAlloc(allocator, state.current_style, .{}) catch |err| {
+        state.state_mutex.unlock();
+        return err;
     };
     state.state_mutex.unlock();
     defer allocator.free(payload);
@@ -418,7 +430,7 @@ fn handleWindowContentRoute(
     }
 
     if (state.last_file) |file_path| {
-        const data = std.fs.cwd().readFileAlloc(allocator, file_path, 8 * 1024 * 1024) catch {
+        const data = std.Io.Dir.cwd().readFileAlloc(io_compat.io, file_path, allocator, .limited(8 * 1024 * 1024)) catch {
             try net_io.writeHttpResponseAny(conn, 500, "text/plain; charset=utf-8", "failed to read file");
             return true;
         };
diff --git a/src/root/service.zig b/src/root/service.zig
index 6a05ec5..bed266d 100644
--- a/src/root/service.zig
+++ b/src/root/service.zig
@@ -32,9 +32,13 @@ const WindowStyle = @import("window_style.zig").WindowStyle;
 
 /// Bundles an `App` with a primary window and optional signal handling for simple applications.
 pub const Service = struct {
+    /// Stores the app.
     app: App,
+    /// Stores the window index.
     window_index: usize,
+    /// Stores the window id.
     window_id: usize,
+    /// Whether process signals enabled.
     process_signals_enabled: bool,
 
     /// Initializes a service, creates the primary window, and binds the provided RPC methods.
@@ -91,6 +95,7 @@ pub const Service = struct {
         const state = win.state();
         state.state_mutex.lock();
         defer state.state_mutex.unlock();
+        state.dispatchPendingNativeUiTasksLocked();
         if (state.isNativeWindowActive()) {
             state.backend.pumpEvents() catch |err| {
                 if (err == error.NativeWindowClosed) {
@@ -98,6 +103,7 @@ pub const Service = struct {
                 }
             };
         }
+        state.dispatchPendingNativeUiTasksLocked();
         state.reconcileChildExit(self.app.allocator);
         return state.close_requested.load(.acquire);
     }
@@ -270,10 +276,15 @@ pub const Service = struct {
 
     /// Invokes a frontend function and waits for a single result.
     pub fn callFrontend(
+        /// Stores the self.
         self: *Service,
+        /// Stores the allocator.
         allocator: std.mem.Allocator,
+        /// Stores the function name.
         function_name: []const u8,
+        /// Stores the args.
         args: anytype,
+        /// Stores the options.
         options: ScriptOptions,
     ) !ScriptEvalResult {
         var win = self.window();
@@ -282,9 +293,13 @@ pub const Service = struct {
 
     /// Invokes a frontend function without waiting for a result.
     pub fn callFrontendFireAndForget(
+        /// Stores the self.
         self: *Service,
+        /// Stores the function name.
         function_name: []const u8,
+        /// Stores the args.
         args: anytype,
+        /// Stores the options.
         options: ScriptOptions,
     ) !void {
         var win = self.window();
@@ -293,9 +308,13 @@ pub const Service = struct {
 
     /// Invokes a frontend function on specific connections.
     pub fn callFrontendOnConnections(
+        /// Stores the self.
         self: *Service,
+        /// Stores the function name.
         function_name: []const u8,
+        /// Stores the args.
         args: anytype,
+        /// Stores the connection ids.
         connection_ids: []const usize,
     ) !void {
         var win = self.window();
@@ -310,11 +329,17 @@ pub const Service = struct {
 
     /// Invokes a frontend function on specific connections and waits for all results.
     pub fn callFrontendAwaitConnections(
+        /// Stores the self.
         self: *Service,
+        /// Stores the allocator.
         allocator: std.mem.Allocator,
+        /// Stores the function name.
         function_name: []const u8,
+        /// Stores the args.
         args: anytype,
+        /// Stores the connection ids.
         connection_ids: []const usize,
+        /// Stores the timeout ms.
         timeout_ms: ?u32,
     ) ![]FrontendCallResult {
         var win = self.window();
@@ -323,10 +348,15 @@ pub const Service = struct {
 
     /// Invokes a frontend function on all clients and waits for all results.
     pub fn callFrontendAwaitAll(
+        /// Stores the self.
         self: *Service,
+        /// Stores the allocator.
         allocator: std.mem.Allocator,
+        /// Stores the function name.
         function_name: []const u8,
+        /// Stores the args.
         args: anytype,
+        /// Stores the timeout ms.
         timeout_ms: ?u32,
     ) ![]FrontendCallResult {
         var win = self.window();
@@ -335,9 +365,13 @@ pub const Service = struct {
 
     /// Evaluates JavaScript on the frontend and waits for a result.
     pub fn evalScript(
+        /// Stores the self.
         self: *Service,
+        /// Stores the allocator.
         allocator: std.mem.Allocator,
+        /// Stores the script.
         script: []const u8,
+        /// Stores the options.
         options: ScriptOptions,
     ) !ScriptEvalResult {
         var win = self.window();
diff --git a/src/root/tests.zig b/src/root/tests.zig
index f365035..d501a3c 100644
--- a/src/root/tests.zig
+++ b/src/root/tests.zig
@@ -1,5 +1,7 @@
 const std = @import("std");
 const builtin = @import("builtin");
+const time_compat = @import("time_compat");
+const io_compat = @import("io_compat");
 const webui = @import("webui");
 const core_runtime = webui.runtime;
 const App = webui.App;
@@ -24,10 +26,20 @@ const runtime_helpers_js = webui.runtime_helpers_js;
 const pinnedMoveGuardEnabled = webui.pinnedMoveGuardEnabled;
 
 const readAllFromStream = webui.test_helpers.readAllFromStream;
+const readFromPlainStream = webui.test_helpers.readFromPlainStream;
+const readExactBufferedFromStream = webui.test_helpers.readExactBufferedFromStream;
 const httpRoundTrip = webui.test_helpers.httpRoundTrip;
 const httpRoundTripWithHeaders = webui.test_helpers.httpRoundTripWithHeaders;
 const readHttpHeadersFromStream = webui.test_helpers.readHttpHeadersFromStream;
 const httpResponseBody = webui.test_helpers.httpResponseBody;
+const writeAllToStream = webui.test_helpers.writeAllToStream;
+
+const subprocess_timeout: std.Io.Timeout = .{
+    .duration = .{
+        .raw = .{ .nanoseconds = 90 * std.time.ns_per_s },
+        .clock = .boot,
+    },
+};
 
 fn hasCapability(haystack: []const WindowCapability, needle: WindowCapability) bool {
     for (haystack) |cap| {
@@ -37,19 +49,26 @@ fn hasCapability(haystack: []const WindowCapability, needle: WindowCapability) b
 }
 
 fn isNativeCloseSmokeChildProcess() bool {
-    const value = std.process.getEnvVarOwned(std.heap.page_allocator, "WEBUI_NATIVE_CLOSE_SMOKE_CHILD") catch return false;
+    const value = std.testing.environ.getAlloc(std.heap.page_allocator, "WEBUI_NATIVE_CLOSE_SMOKE_CHILD") catch return false;
+    defer std.heap.page_allocator.free(value);
+    return std.mem.eql(u8, value, "1");
+}
+
+fn isNativeCloseSmokeSubprocessEnabled() bool {
+    const value = std.testing.environ.getAlloc(std.heap.page_allocator, "WEBUI_ENABLE_SUBPROCESS_SMOKE") catch return false;
     defer std.heap.page_allocator.free(value);
     return std.mem.eql(u8, value, "1");
 }
 
 fn runNativeCloseSmokeFlow() anyerror!void {
     const SmokeRpc = struct {
+        /// Returns the smoke-test sentinel value expected by the frontend bootstrap.
         pub fn ping() []const u8 {
             return "pong";
         }
     };
 
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var service = try Service.init(gpa.allocator(), SmokeRpc, .{
@@ -84,7 +103,7 @@ fn runNativeCloseSmokeFlow() anyerror!void {
     const render_state = service.runtimeRenderState();
     if (render_state.active_surface != .native_webview) return error.SkipZigTest;
 
-    std.Thread.sleep(120 * std.time.ns_per_ms);
+    time_compat.sleep(120 * std.time.ns_per_ms);
 
     _ = service.control(.close) catch |err| {
         const err_name = @errorName(err);
@@ -96,57 +115,15 @@ fn runNativeCloseSmokeFlow() anyerror!void {
         return err;
     };
 
-    const start_ms = std.time.milliTimestamp();
+    const start_ms = time_compat.milliTimestamp();
     while (!service.shouldExit()) {
-        if (std.time.milliTimestamp() - start_ms > 5000) return error.ServerStartTimeout;
-        std.Thread.sleep(20 * std.time.ns_per_ms);
+        if (time_compat.milliTimestamp() - start_ms > 5000) return error.ServerStartTimeout;
+        time_compat.sleep(20 * std.time.ns_per_ms);
     }
 
     service.shutdown();
 }
 
-fn writeAllStream(stream: std.net.Stream, bytes: []const u8) !void {
-    if (builtin.os.tag == .windows) {
-        var offset: usize = 0;
-        while (offset < bytes.len) {
-            const n = std.posix.send(stream.handle, bytes[offset..], 0) catch |err| switch (err) {
-                error.WouldBlock => {
-                    std.Thread.sleep(std.time.ns_per_ms);
-                    continue;
-                },
-                else => return err,
-            };
-            if (n == 0) return error.Closed;
-            offset += n;
-        }
-        return;
-    }
-    try stream.writeAll(bytes);
-}
-
-fn readStreamCompat(stream: std.net.Stream, buffer: []u8) !usize {
-    if (builtin.os.tag == .windows) {
-        return std.posix.recv(stream.handle, buffer, 0);
-    }
-    return stream.read(buffer);
-}
-
-fn readStreamExactBuffered(stream: std.net.Stream, prebuffer: *[]const u8, out: []u8) !void {
-    var offset: usize = 0;
-    while (offset < out.len and prebuffer.*.len > 0) {
-        const take = @min(out.len - offset, prebuffer.*.len);
-        @memcpy(out[offset .. offset + take], prebuffer.*[0..take]);
-        prebuffer.* = prebuffer.*[take..];
-        offset += take;
-    }
-
-    while (offset < out.len) {
-        const n = try readStreamCompat(stream, out[offset..]);
-        if (n == 0) return error.Closed;
-        offset += n;
-    }
-}
-
 const ServerWsFrame = struct {
     opcode: u8,
     payload: []u8,
@@ -156,9 +133,9 @@ const ServerWsFrame = struct {
     }
 };
 
-fn readServerWsFrame(allocator: std.mem.Allocator, stream: std.net.Stream, prebuffer: *[]const u8) !ServerWsFrame {
+fn readServerWsFrame(allocator: std.mem.Allocator, stream: std.Io.net.Stream, prebuffer: *[]const u8) !ServerWsFrame {
     var header: [2]u8 = undefined;
-    try readStreamExactBuffered(stream, prebuffer, &header);
+    try readExactBufferedFromStream(stream, prebuffer, &header);
 
     const masked = (header[1] & 0x80) != 0;
     if (masked) return error.InvalidWebSocketMasking;
@@ -166,11 +143,11 @@ fn readServerWsFrame(allocator: std.mem.Allocator, stream: std.net.Stream, prebu
     var payload_len_u64: u64 = header[1] & 0x7F;
     if (payload_len_u64 == 126) {
         var ext: [2]u8 = undefined;
-        try readStreamExactBuffered(stream, prebuffer, &ext);
+        try readExactBufferedFromStream(stream, prebuffer, &ext);
         payload_len_u64 = (@as(u64, ext[0]) << 8) | @as(u64, ext[1]);
     } else if (payload_len_u64 == 127) {
         var ext: [8]u8 = undefined;
-        try readStreamExactBuffered(stream, prebuffer, &ext);
+        try readExactBufferedFromStream(stream, prebuffer, &ext);
         payload_len_u64 =
             (@as(u64, ext[0]) << 56) |
             (@as(u64, ext[1]) << 48) |
@@ -185,7 +162,7 @@ fn readServerWsFrame(allocator: std.mem.Allocator, stream: std.net.Stream, prebu
     const payload = try allocator.alloc(u8, @intCast(payload_len_u64));
     errdefer allocator.free(payload);
     if (payload.len != 0) {
-        try readStreamExactBuffered(stream, prebuffer, payload);
+        try readExactBufferedFromStream(stream, prebuffer, payload);
     }
 
     return .{
@@ -194,6 +171,45 @@ fn readServerWsFrame(allocator: std.mem.Allocator, stream: std.net.Stream, prebu
     };
 }
 
+fn readServerWsFrameWithTimeout(stream: std.Io.net.Stream, prebuffer: []const u8, timeout_ms: i64) !ServerWsFrame {
+    const AsyncFrameRead = struct {
+        done: std.atomic.Value(bool) = std.atomic.Value(bool).init(false),
+        err: ?anyerror = null,
+        frame: ?ServerWsFrame = null,
+        stream: std.Io.net.Stream,
+        prebuffer: []const u8,
+
+        fn run(self: *@This()) void {
+            var buffered = self.prebuffer;
+            self.frame = readServerWsFrame(std.heap.page_allocator, self.stream, &buffered) catch |err| {
+                self.err = err;
+                self.done.store(true, .release);
+                return;
+            };
+            self.done.store(true, .release);
+        }
+    };
+
+    var op = AsyncFrameRead{
+        .stream = stream,
+        .prebuffer = prebuffer,
+    };
+    const reader_thread = try std.Thread.spawn(.{}, AsyncFrameRead.run, .{&op});
+    defer reader_thread.join();
+
+    const deadline_ms = time_compat.milliTimestamp() + timeout_ms;
+    while (!op.done.load(.acquire)) {
+        if (time_compat.milliTimestamp() >= deadline_ms) {
+            stream.shutdown(io_compat.io, .both) catch {};
+            return error.ServerStartTimeout;
+        }
+        time_compat.sleep(5 * std.time.ns_per_ms);
+    }
+
+    if (op.err) |err| return err;
+    return op.frame orelse error.Closed;
+}
+
 fn appendMaskedClientWsFrame(out: *std.array_list.Managed(u8), opcode: u8, payload: []const u8) !void {
     const mask = [_]u8{ 0x12, 0x34, 0x56, 0x78 };
     try out.append(0x80 | opcode);
@@ -213,10 +229,12 @@ fn appendMaskedClientWsFrame(out: *std.array_list.Managed(u8), opcode: u8, paylo
 }
 
 test "window lifecycle" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
-    var app = try App.init(gpa.allocator(), .{});
+    var app = try App.init(gpa.allocator(), .{
+        .launch_policy = .{ .first = .web_url, .second = null, .third = null },
+    });
     defer app.deinit();
 
     var win = try app.newWindow(.{ .title = "Lifecycle" });
@@ -226,8 +244,34 @@ test "window lifecycle" {
     app.shutdown();
 }
 
+test "app shutdown does not synthesize disconnected event without a frontend" {
+    const Capture = struct {
+        var disconnected_count: usize = 0;
+
+        fn onEvent(_: ?*anyopaque, event: *const Event) void {
+            if (event.kind == .disconnected) disconnected_count += 1;
+        }
+    };
+
+    Capture.disconnected_count = 0;
+
+    var gpa = std.heap.DebugAllocator(.{}){};
+    defer _ = gpa.deinit();
+
+    var app = try App.init(gpa.allocator(), .{});
+    defer app.deinit();
+
+    var win = try app.newWindow(.{ .title = "ShutdownDisconnectNoFrontend" });
+    win.onEvent(Capture.onEvent, null);
+    try win.showHtml("<html><body>shutdown-disconnect-no-frontend</body></html>");
+    try app.run();
+
+    app.shutdown();
+    try std.testing.expectEqual(@as(usize, 0), Capture.disconnected_count);
+}
+
 test "browser fallback serves window html over local http" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -243,11 +287,11 @@ test "browser fallback serves window html over local http" {
     defer gpa.allocator().free(local_url);
     try std.testing.expect(std.mem.startsWith(u8, local_url, "http://127.0.0.1:"));
 
-    const address = try std.net.Address.parseIp4("127.0.0.1", win.state().server_port);
-    const stream = try std.net.tcpConnectToAddress(address);
-    defer stream.close();
+    const address = try std.Io.net.IpAddress.parseIp4("127.0.0.1", win.state().server_port);
+    const stream = try std.Io.net.IpAddress.connect(&address, io_compat.io, .{ .mode = .stream });
+    defer stream.close(io_compat.io);
 
-    try writeAllStream(
+    try writeAllToStream(
         stream,
         "GET / HTTP/1.1\r\n" ++
             "Host: 127.0.0.1\r\n" ++
@@ -271,33 +315,42 @@ test "native webview close smoke child target" {
 
 test "native webview close smoke subprocess exits cleanly" {
     if (isNativeCloseSmokeChildProcess()) return;
+    // Running the full test binary inside this test is expensive; keep it opt-in
+    // so default CI remains deterministic and non-hanging.
+    if (!isNativeCloseSmokeSubprocessEnabled()) return error.SkipZigTest;
 
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
     const allocator = gpa.allocator();
 
-    const exe_path = try std.fs.selfExePathAlloc(allocator);
+    const exe_path = try std.process.executablePathAlloc(std.testing.io, allocator);
     defer allocator.free(exe_path);
 
     var argv = std.array_list.Managed([]const u8).init(allocator);
     defer argv.deinit();
     try argv.append(exe_path);
 
-    var child = std.process.Child.init(argv.items, allocator);
-    var env_map = try std.process.getEnvMap(allocator);
+    var env_map = try std.testing.environ.createMap(allocator);
     defer env_map.deinit();
     try env_map.put("WEBUI_NATIVE_CLOSE_SMOKE_CHILD", "1");
-    child.env_map = &env_map;
-
-    const term = try child.spawnAndWait();
-    switch (term) {
-        .Exited => |code| try std.testing.expectEqual(@as(u8, 0), code),
+    const result = try std.process.run(allocator, std.testing.io, .{
+        .argv = argv.items,
+        .environ_map = &env_map,
+        .stdout_limit = .limited(16 * 1024 * 1024),
+        .stderr_limit = .limited(16 * 1024 * 1024),
+        .timeout = subprocess_timeout,
+    });
+    defer allocator.free(result.stdout);
+    defer allocator.free(result.stderr);
+
+    switch (result.term) {
+        .exited => |code| try std.testing.expectEqual(@as(u8, 0), code),
         else => return error.TestUnexpectedResult,
     }
 }
 
 test "browser fallback server is reachable across repeated connects" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -323,7 +376,7 @@ test "browser fallback server is reachable across repeated connects" {
 }
 
 test "public network mode binds server with public listen policy" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -343,7 +396,7 @@ test "public network mode binds server with public listen policy" {
 }
 
 test "websocket upgrade uses same http server port" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -355,11 +408,11 @@ test "websocket upgrade uses same http server port" {
     try win.showHtml("<html><body>ws-same-port</body></html>");
     try app.run();
 
-    const address = try std.net.Address.parseIp4("127.0.0.1", win.state().server_port);
-    const stream = try std.net.tcpConnectToAddress(address);
-    defer stream.close();
+    const address = try std.Io.net.IpAddress.parseIp4("127.0.0.1", win.state().server_port);
+    const stream = try std.Io.net.IpAddress.connect(&address, io_compat.io, .{ .mode = .stream });
+    defer stream.close(io_compat.io);
 
-    try writeAllStream(
+    try writeAllToStream(
         stream,
         "GET /webui/ws?client_id=test-client HTTP/1.1\r\n" ++
             "Host: 127.0.0.1\r\n" ++
@@ -379,7 +432,7 @@ test "websocket upgrade uses same http server port" {
 }
 
 test "websocket upgrade preserves same-packet first frame" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -391,9 +444,9 @@ test "websocket upgrade preserves same-packet first frame" {
     try win.showHtml("<html><body>ws-prefetch-ok</body></html>");
     try app.run();
 
-    const address = try std.net.Address.parseIp4("127.0.0.1", win.state().server_port);
-    const stream = try std.net.tcpConnectToAddress(address);
-    defer stream.close();
+    const address = try std.Io.net.IpAddress.parseIp4("127.0.0.1", win.state().server_port);
+    const stream = try std.Io.net.IpAddress.connect(&address, io_compat.io, .{ .mode = .stream });
+    defer stream.close(io_compat.io);
 
     var request = std.array_list.Managed(u8).init(gpa.allocator());
     defer request.deinit();
@@ -407,23 +460,22 @@ test "websocket upgrade preserves same-packet first frame" {
             "\r\n",
     );
     try appendMaskedClientWsFrame(&request, 0x9, "hi");
-    try writeAllStream(stream, request.items);
+    try writeAllToStream(stream, request.items);
 
     const response = try readHttpHeadersFromStream(gpa.allocator(), stream, 64 * 1024);
     defer gpa.allocator().free(response);
 
     try std.testing.expect(std.mem.indexOf(u8, response, "HTTP/1.1 101 Switching Protocols") != null);
 
-    var prebuffer = httpResponseBody(response);
-    const frame = try readServerWsFrame(gpa.allocator(), stream, &prebuffer);
-    defer frame.deinit(gpa.allocator());
+    const frame = try readServerWsFrameWithTimeout(stream, httpResponseBody(response), 2000);
+    defer frame.deinit(std.heap.page_allocator);
 
     try std.testing.expectEqual(@as(u8, 0xA), frame.opcode);
     try std.testing.expectEqualStrings("hi", frame.payload);
 }
 
 test "invalid websocket upgrade returns single 400 response" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -453,7 +505,7 @@ test "invalid websocket upgrade returns single 400 response" {
 }
 
 test "http server remains responsive after partial request disconnect bursts" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -465,12 +517,12 @@ test "http server remains responsive after partial request disconnect bursts" {
     try win.showHtml("<html><body>partial-disconnect-ok</body></html>");
     try app.run();
 
-    const address = try std.net.Address.parseIp4("127.0.0.1", win.state().server_port);
+    const address = try std.Io.net.IpAddress.parseIp4("127.0.0.1", win.state().server_port);
     var bursts: usize = 0;
     while (bursts < 64) : (bursts += 1) {
-        const stream = try std.net.tcpConnectToAddress(address);
-        try writeAllStream(stream, "GET / HTTP/1.1\r\nHost: 127.0.0.1\r\n");
-        stream.close();
+        const stream = try std.Io.net.IpAddress.connect(&address, io_compat.io, .{ .mode = .stream });
+        try writeAllToStream(stream, "GET / HTTP/1.1\r\nHost: 127.0.0.1\r\n");
+        stream.close(io_compat.io);
     }
 
     var checks: usize = 0;
@@ -483,7 +535,7 @@ test "http server remains responsive after partial request disconnect bursts" {
 }
 
 test "websocket upgrade survives repeated connect-disconnect churn" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -495,11 +547,11 @@ test "websocket upgrade survives repeated connect-disconnect churn" {
     try win.showHtml("<html><body>ws-churn-ok</body></html>");
     try app.run();
 
-    const address = try std.net.Address.parseIp4("127.0.0.1", win.state().server_port);
+    const address = try std.Io.net.IpAddress.parseIp4("127.0.0.1", win.state().server_port);
     var handshake_buf: [512]u8 = undefined;
     var idx: usize = 0;
     while (idx < 48) : (idx += 1) {
-        const stream = try std.net.tcpConnectToAddress(address);
+        const stream = try std.Io.net.IpAddress.connect(&address, io_compat.io, .{ .mode = .stream });
         const request = try std.fmt.bufPrint(
             &handshake_buf,
             "GET /webui/ws?client_id=churn-{d} HTTP/1.1\r\n" ++
@@ -511,12 +563,12 @@ test "websocket upgrade survives repeated connect-disconnect churn" {
                 "\r\n",
             .{idx},
         );
-        try writeAllStream(stream, request);
+        try writeAllToStream(stream, request);
 
         const response = try readHttpHeadersFromStream(gpa.allocator(), stream, 64 * 1024);
         defer gpa.allocator().free(response);
         try std.testing.expect(std.mem.indexOf(u8, response, "HTTP/1.1 101 Switching Protocols") != null);
-        stream.close();
+        stream.close(io_compat.io);
     }
 
     const response = try httpRoundTrip(gpa.allocator(), win.state().server_port, "GET", "/", null);
@@ -534,7 +586,7 @@ test "mixed concurrent http routes remain stable under socket churn" {
     };
     const Worker = struct {
         fn run(ctx: *Ctx) void {
-            var gpa_thread = std.heap.GeneralPurposeAllocator(.{}){};
+            var gpa_thread = std.heap.DebugAllocator(.{}){};
             defer _ = gpa_thread.deinit();
             const allocator = gpa_thread.allocator();
 
@@ -560,7 +612,7 @@ test "mixed concurrent http routes remain stable under socket churn" {
         }
     };
 
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -588,7 +640,7 @@ test "mixed concurrent http routes remain stable under socket churn" {
 }
 
 test "tls enabled runtime redirects plaintext http and serves https content on same port" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -616,8 +668,9 @@ test "tls enabled runtime redirects plaintext http and serves https content on s
 
 test "window control route stays responsive during long running rpc" {
     const DemoRpc = struct {
+        /// Sleeps long enough to exercise control-route responsiveness during a busy RPC.
         pub fn slow() []const u8 {
-            std.Thread.sleep(900 * std.time.ns_per_ms);
+            time_compat.sleep(900 * std.time.ns_per_ms);
             return "done";
         }
     };
@@ -629,7 +682,7 @@ test "window control route stays responsive during long running rpc" {
         err: ?anyerror = null,
 
         fn run(ctx: *@This()) void {
-            var gpa_thread = std.heap.GeneralPurposeAllocator(.{}){};
+            var gpa_thread = std.heap.DebugAllocator(.{}){};
             defer _ = gpa_thread.deinit();
             const allocator = gpa_thread.allocator();
 
@@ -648,7 +701,7 @@ test "window control route stays responsive during long running rpc" {
         }
     };
 
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -670,9 +723,9 @@ test "window control route stays responsive during long running rpc" {
     const rpc_thread = try std.Thread.spawn(.{}, RpcCallCtx.run, .{&rpc_call_ctx});
     errdefer rpc_thread.join();
 
-    std.Thread.sleep(40 * std.time.ns_per_ms);
+    time_compat.sleep(40 * std.time.ns_per_ms);
 
-    const started_ns = std.time.nanoTimestamp();
+    const started_ns = time_compat.nanoTimestamp();
     const control_response = try httpRoundTrip(
         gpa.allocator(),
         win.state().server_port,
@@ -681,7 +734,7 @@ test "window control route stays responsive during long running rpc" {
         null,
     );
     defer gpa.allocator().free(control_response);
-    const elapsed_ms = @as(i64, @intCast(@divTrunc(std.time.nanoTimestamp() - started_ns, std.time.ns_per_ms)));
+    const elapsed_ms = @as(i64, @intCast(@divTrunc(time_compat.nanoTimestamp() - started_ns, std.time.ns_per_ms)));
 
     try std.testing.expect(std.mem.indexOf(u8, control_response, "HTTP/1.1 200 OK") != null);
     try std.testing.expect(elapsed_ms < 400);
@@ -695,7 +748,7 @@ test "window control route stays responsive during long running rpc" {
 }
 
 test "native_webview launch order keeps local runtime reachable" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -716,11 +769,11 @@ test "native_webview launch order keeps local runtime reachable" {
     defer gpa.allocator().free(local_url);
     try std.testing.expect(std.mem.startsWith(u8, local_url, "http://127.0.0.1:"));
 
-    const address = try std.net.Address.parseIp4("127.0.0.1", win.state().server_port);
-    const stream = try std.net.tcpConnectToAddress(address);
-    defer stream.close();
+    const address = try std.Io.net.IpAddress.parseIp4("127.0.0.1", win.state().server_port);
+    const stream = try std.Io.net.IpAddress.connect(&address, io_compat.io, .{ .mode = .stream });
+    defer stream.close(io_compat.io);
 
-    try writeAllStream(
+    try writeAllToStream(
         stream,
         "GET / HTTP/1.1\r\n" ++
             "Host: 127.0.0.1\r\n" ++
@@ -738,7 +791,7 @@ test "native_webview launch order keeps local runtime reachable" {
 }
 
 test "native_webview only mode still exposes local runtime url" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -755,7 +808,7 @@ test "native_webview only mode still exposes local runtime url" {
 test "linked child exit requests close immediately" {
     if (builtin.os.tag == .windows or builtin.os.tag == .wasi) return error.SkipZigTest;
 
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -767,14 +820,16 @@ test "linked child exit requests close immediately" {
     try win.showHtml("<html><body>child-exit-close</body></html>");
     try app.run();
 
-    var child = std.process.Child.init(&.{ "sh", "-c", "exit 0" }, gpa.allocator());
-    child.stdin_behavior = .Ignore;
-    child.stdout_behavior = .Ignore;
-    child.stderr_behavior = .Ignore;
-    try child.spawn();
+    const child = try std.process.spawn(std.testing.io, .{
+        .argv = &.{ "sh", "-c", "exit 0" },
+        .stdin = .ignore,
+        .stdout = .ignore,
+        .stderr = .ignore,
+    });
+    const child_pid_i64: i64 = @as(i64, @intCast(child.id orelse return error.TestUnexpectedResult));
 
     win.state().state_mutex.lock();
-    win.state().launched_browser_pid = @as(i64, @intCast(child.id));
+    win.state().launched_browser_pid = child_pid_i64;
     win.state().launched_browser_is_child = true;
     win.state().launched_browser_lifecycle_linked = true;
     win.state().state_mutex.unlock();
@@ -790,7 +845,7 @@ test "linked child exit requests close immediately" {
             closed = true;
             break;
         }
-        std.Thread.sleep(5 * std.time.ns_per_ms);
+        time_compat.sleep(5 * std.time.ns_per_ms);
     }
 
     try std.testing.expect(closed);
@@ -799,7 +854,7 @@ test "linked child exit requests close immediately" {
 test "shutdown in web mode does not terminate tracked browser child process" {
     if (builtin.os.tag == .windows or builtin.os.tag == .wasi) return error.SkipZigTest;
 
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -811,36 +866,38 @@ test "shutdown in web mode does not terminate tracked browser child process" {
     try win.showHtml("<html><body>shutdown-web-mode</body></html>");
     try app.run();
 
-    var child = std.process.Child.init(&.{ "sh", "-c", "sleep 5" }, gpa.allocator());
-    child.stdin_behavior = .Ignore;
-    child.stdout_behavior = .Ignore;
-    child.stderr_behavior = .Ignore;
-    try child.spawn();
+    var child = try std.process.spawn(std.testing.io, .{
+        .argv = &.{ "sh", "-c", "sleep 5" },
+        .stdin = .ignore,
+        .stdout = .ignore,
+        .stderr = .ignore,
+    });
+    const child_pid_i64: i64 = @as(i64, @intCast(child.id orelse return error.TestUnexpectedResult));
     defer {
-        core_runtime.terminateBrowserProcess(gpa.allocator(), @as(i64, @intCast(child.id)));
+        core_runtime.terminateBrowserProcess(gpa.allocator(), child_pid_i64);
         // On macOS this test probes termination using waitpid(WNOHANG) below,
         // which may already reap the child. Avoid double-wait on that platform.
-        if (builtin.os.tag != .macos) {
-            _ = child.wait() catch {};
+        if (builtin.os.tag != .macos and child.id != null) {
+            _ = child.wait(std.testing.io) catch {};
         }
     }
 
     win.state().state_mutex.lock();
-    win.state().launched_browser_pid = @as(i64, @intCast(child.id));
+    win.state().launched_browser_pid = child_pid_i64;
     win.state().launched_browser_is_child = true;
     win.state().launched_browser_lifecycle_linked = true;
     win.state().state_mutex.unlock();
 
     app.shutdown();
-    std.Thread.sleep(20 * std.time.ns_per_ms);
+    time_compat.sleep(20 * std.time.ns_per_ms);
 
-    try std.testing.expect(core_runtime.isProcessAlive(@as(i64, @intCast(child.id))));
+    try std.testing.expect(core_runtime.isProcessAlive(child_pid_i64));
 }
 
 test "shutdown in webview mode terminates tracked browser child process" {
     if (builtin.os.tag == .windows or builtin.os.tag == .wasi) return error.SkipZigTest;
 
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -852,21 +909,21 @@ test "shutdown in webview mode terminates tracked browser child process" {
     try win.showHtml("<html><body>shutdown-webview-mode</body></html>");
     try app.run();
 
-    var child = std.process.Child.init(&.{ "sh", "-c", "sleep 5" }, gpa.allocator());
-    child.stdin_behavior = .Ignore;
-    child.stdout_behavior = .Ignore;
-    child.stderr_behavior = .Ignore;
-    try child.spawn();
+    var child = try std.process.spawn(std.testing.io, .{
+        .argv = &.{ "sh", "-c", "sleep 5" },
+        .stdin = .ignore,
+        .stdout = .ignore,
+        .stderr = .ignore,
+    });
+    const child_pid_i64: i64 = @as(i64, @intCast(child.id orelse return error.TestUnexpectedResult));
     defer {
-        core_runtime.terminateBrowserProcess(gpa.allocator(), @as(i64, @intCast(child.id)));
+        core_runtime.terminateBrowserProcess(gpa.allocator(), child_pid_i64);
         // On macOS this test may already reap via waitpid(WNOHANG) while polling.
         // Avoid a second wait() call that would hit std.posix.waitpid(.CHILD).
-        if (builtin.os.tag != .macos) {
-            _ = child.wait() catch {};
+        if (builtin.os.tag != .macos and child.id != null) {
+            _ = child.wait(std.testing.io) catch {};
         }
     }
-
-    const child_pid_i64: i64 = @as(i64, @intCast(child.id));
     win.state().state_mutex.lock();
     win.state().launched_browser_pid = child_pid_i64;
     win.state().launched_browser_is_child = true;
@@ -879,7 +936,7 @@ test "shutdown in webview mode terminates tracked browser child process" {
     var alive = true;
     var attempts: usize = 0;
     while (alive and attempts < 100) : (attempts += 1) {
-        std.Thread.sleep(10 * std.time.ns_per_ms);
+        time_compat.sleep(10 * std.time.ns_per_ms);
         if (builtin.os.tag == .macos) {
             // macOS can report a killed child as alive until it is reaped; use
             // waitpid(WNOHANG) as authoritative termination detection.
@@ -893,8 +950,26 @@ test "shutdown in webview mode terminates tracked browser child process" {
     try std.testing.expect(!alive);
 }
 
+test "browser attach verification times out when no frontend connects" {
+    var gpa = std.heap.DebugAllocator(.{}){};
+    defer _ = gpa.deinit();
+
+    var app = try App.init(gpa.allocator(), .{
+        .launch_policy = .{ .first = .browser_window, .second = null, .third = null },
+    });
+    defer app.deinit();
+
+    var win = try app.newWindow(.{ .title = "AttachTimeout" });
+    win.state().state_mutex.lock();
+    win.state().runtime_render_state.active_surface = .browser_window;
+    win.state().runtime_render_state.active_transport = .browser_fallback;
+    win.state().state_mutex.unlock();
+
+    try std.testing.expect(!win.state().waitForFrontendAttachment(gpa.allocator(), 1));
+}
+
 test "browser spawn decision matrix across launch modes" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app_web_url = try App.init(gpa.allocator(), .{
@@ -905,7 +980,7 @@ test "browser spawn decision matrix across launch modes" {
     win_web_url.state().state_mutex.lock();
     const web_url_attempt = win_web_url.state().shouldAttemptBrowserSpawnLocked(gpa.allocator(), true);
     win_web_url.state().state_mutex.unlock();
-    try std.testing.expect(!web_url_attempt);
+    try std.testing.expect(web_url_attempt);
 
     var app_browser = try App.init(gpa.allocator(), .{
         .launch_policy = .{ .first = .browser_window, .second = .web_url, .third = null },
@@ -930,7 +1005,7 @@ test "browser spawn decision matrix across launch modes" {
         try std.testing.expect(native_only_attempt);
     } else {
         try std.testing.expectEqual(@as(LaunchSurface, .web_url), native_only_surface);
-        try std.testing.expect(!native_only_attempt);
+        try std.testing.expect(native_only_attempt);
     }
 
     var app_dual = try App.init(gpa.allocator(), .{
@@ -952,7 +1027,7 @@ test "browser spawn decision matrix across launch modes" {
 test "local render spawn is skipped while tracked browser process is alive" {
     if (builtin.os.tag == .windows or builtin.os.tag == .wasi) return error.SkipZigTest;
 
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -962,17 +1037,17 @@ test "local render spawn is skipped while tracked browser process is alive" {
 
     var win = try app.newWindow(.{ .title = "SpawnSkipAlivePid" });
 
-    var child = std.process.Child.init(&.{ "sh", "-c", "sleep 5" }, gpa.allocator());
-    child.stdin_behavior = .Ignore;
-    child.stdout_behavior = .Ignore;
-    child.stderr_behavior = .Ignore;
-    try child.spawn();
+    var child = try std.process.spawn(std.testing.io, .{
+        .argv = &.{ "sh", "-c", "sleep 5" },
+        .stdin = .ignore,
+        .stdout = .ignore,
+        .stderr = .ignore,
+    });
+    const child_pid_i64: i64 = @as(i64, @intCast(child.id orelse return error.TestUnexpectedResult));
     defer {
-        core_runtime.terminateBrowserProcess(gpa.allocator(), @as(i64, @intCast(child.id)));
-        _ = child.wait() catch {};
+        core_runtime.terminateBrowserProcess(gpa.allocator(), child_pid_i64);
+        if (child.id != null) _ = child.wait(std.testing.io) catch {};
     }
-
-    const child_pid_i64: i64 = @as(i64, @intCast(child.id));
     win.state().state_mutex.lock();
     win.state().launched_browser_pid = child_pid_i64;
     const attempt = win.state().shouldAttemptBrowserSpawnLocked(gpa.allocator(), true);
@@ -988,7 +1063,7 @@ test "local render spawn is skipped while tracked browser process is alive" {
 test "local render spawn clears stale tracked browser process before relaunch" {
     if (builtin.os.tag == .windows or builtin.os.tag == .wasi) return error.SkipZigTest;
 
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -998,14 +1073,14 @@ test "local render spawn clears stale tracked browser process before relaunch" {
 
     var win = try app.newWindow(.{ .title = "SpawnClearDeadPid" });
 
-    var child = std.process.Child.init(&.{ "sh", "-c", "exit 0" }, gpa.allocator());
-    child.stdin_behavior = .Ignore;
-    child.stdout_behavior = .Ignore;
-    child.stderr_behavior = .Ignore;
-    try child.spawn();
-    _ = try child.wait();
-
-    const dead_pid_i64: i64 = @as(i64, @intCast(child.id));
+    var child = try std.process.spawn(std.testing.io, .{
+        .argv = &.{ "sh", "-c", "exit 0" },
+        .stdin = .ignore,
+        .stdout = .ignore,
+        .stderr = .ignore,
+    });
+    const dead_pid_i64: i64 = @as(i64, @intCast(child.id orelse return error.TestUnexpectedResult));
+    _ = try child.wait(std.testing.io);
     win.state().state_mutex.lock();
     win.state().launched_browser_pid = dead_pid_i64;
     const attempt = win.state().shouldAttemptBrowserSpawnLocked(gpa.allocator(), true);
@@ -1017,7 +1092,7 @@ test "local render spawn clears stale tracked browser process before relaunch" {
 }
 
 test "native webview mode bootstraps host process spawn when backend is not ready" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -1041,7 +1116,7 @@ test "native webview mode bootstraps host process spawn when backend is not read
 }
 
 test "effective browser launch options reserve native host bootstrap for webview surface" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app_browser = try App.init(gpa.allocator(), .{
@@ -1085,7 +1160,7 @@ test "effective browser launch options reserve native host bootstrap for webview
 }
 
 test "browser launch failure fallback advances from active launch surface" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -1114,8 +1189,37 @@ test "browser launch failure fallback advances from active launch surface" {
     try std.testing.expect(!win.state().resolveAfterBrowserLaunchFailure(.web_url));
 }
 
+test "browser launch failure skips unavailable native fallback surface" {
+    var gpa = std.heap.DebugAllocator(.{}){};
+    defer _ = gpa.deinit();
+
+    var app = try App.init(gpa.allocator(), .{
+        .launch_policy = .{
+            .first = .browser_window,
+            .second = .native_webview,
+            .third = .web_url,
+        },
+    });
+    defer app.deinit();
+
+    var win = try app.newWindow(.{ .title = "LaunchFailureSkipsUnavailableNative" });
+    win.state().state_mutex.lock();
+    defer win.state().state_mutex.unlock();
+
+    win.state().backend = .{ .native_enabled = false };
+    win.state().native_capabilities = win.state().backend.capabilities();
+    win.state().runtime_render_state.active_surface = .browser_window;
+    win.state().runtime_render_state.active_transport = .browser_fallback;
+
+    try std.testing.expect(try win.state().advanceAfterBrowserLaunchFailureLocked(.browser_window));
+    try std.testing.expectEqual(@as(LaunchSurface, .web_url), win.state().runtime_render_state.active_surface);
+    try std.testing.expectEqual(@as(TransportMode, .browser_fallback), win.state().runtime_render_state.active_transport);
+    try std.testing.expect(win.state().runtime_render_state.fallback_applied);
+    try std.testing.expectEqual(@as(?FallbackReason, .launch_failed), win.state().runtime_render_state.fallback_reason);
+}
+
 test "native launch request records fallback when browser app-window is launched" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -1152,7 +1256,7 @@ test "native launch request records fallback when browser app-window is launched
 test "window_closing lifecycle message is ignored while tracked browser pid is alive" {
     if (builtin.os.tag == .windows or builtin.os.tag == .wasi) return error.SkipZigTest;
 
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -1164,18 +1268,20 @@ test "window_closing lifecycle message is ignored while tracked browser pid is a
     try win.showHtml("<html><body>lifecycle-close-alive</body></html>");
     try app.run();
 
-    var child = std.process.Child.init(&.{ "sh", "-c", "sleep 5" }, gpa.allocator());
-    child.stdin_behavior = .Ignore;
-    child.stdout_behavior = .Ignore;
-    child.stderr_behavior = .Ignore;
-    try child.spawn();
+    var child = try std.process.spawn(std.testing.io, .{
+        .argv = &.{ "sh", "-c", "sleep 5" },
+        .stdin = .ignore,
+        .stdout = .ignore,
+        .stderr = .ignore,
+    });
+    const child_pid_i64: i64 = @as(i64, @intCast(child.id orelse return error.TestUnexpectedResult));
     defer {
-        std.posix.kill(@as(std.posix.pid_t, @intCast(child.id)), std.posix.SIG.TERM) catch {};
-        _ = child.wait() catch {};
+        std.posix.kill(@as(std.posix.pid_t, @intCast(child_pid_i64)), std.posix.SIG.TERM) catch {};
+        if (child.id != null) _ = child.wait(std.testing.io) catch {};
     }
 
     win.state().state_mutex.lock();
-    win.state().launched_browser_pid = @as(i64, @intCast(child.id));
+    win.state().launched_browser_pid = child_pid_i64;
     win.state().launched_browser_is_child = true;
     win.state().launched_browser_lifecycle_linked = false;
     win.state().state_mutex.unlock();
@@ -1193,7 +1299,7 @@ test "window_closing lifecycle message is ignored while tracked browser pid is a
 test "window_closing lifecycle message uses grace delay in browser-window mode" {
     if (builtin.os.tag == .windows or builtin.os.tag == .wasi) return error.SkipZigTest;
 
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -1205,18 +1311,20 @@ test "window_closing lifecycle message uses grace delay in browser-window mode"
     try win.showHtml("<html><body>lifecycle-close-browser-window</body></html>");
     try app.run();
 
-    var child = std.process.Child.init(&.{ "sh", "-c", "sleep 5" }, gpa.allocator());
-    child.stdin_behavior = .Ignore;
-    child.stdout_behavior = .Ignore;
-    child.stderr_behavior = .Ignore;
-    try child.spawn();
+    var child = try std.process.spawn(std.testing.io, .{
+        .argv = &.{ "sh", "-c", "sleep 5" },
+        .stdin = .ignore,
+        .stdout = .ignore,
+        .stderr = .ignore,
+    });
+    const child_pid_i64: i64 = @as(i64, @intCast(child.id orelse return error.TestUnexpectedResult));
     defer {
-        std.posix.kill(@as(std.posix.pid_t, @intCast(child.id)), std.posix.SIG.TERM) catch {};
-        _ = child.wait() catch {};
+        std.posix.kill(@as(std.posix.pid_t, @intCast(child_pid_i64)), std.posix.SIG.TERM) catch {};
+        if (child.id != null) _ = child.wait(std.testing.io) catch {};
     }
 
     win.state().state_mutex.lock();
-    win.state().launched_browser_pid = @as(i64, @intCast(child.id));
+    win.state().launched_browser_pid = child_pid_i64;
     win.state().launched_browser_is_child = true;
     win.state().launched_browser_lifecycle_linked = false;
     win.state().runtime_render_state.active_surface = .browser_window;
@@ -1232,7 +1340,7 @@ test "window_closing lifecycle message uses grace delay in browser-window mode"
     try std.testing.expect(!close_immediate);
 
     win.state().state_mutex.lock();
-    win.state().lifecycle_close_deadline_ms = std.time.milliTimestamp() - 1;
+    win.state().lifecycle_close_deadline_ms = time_compat.milliTimestamp() - 1;
     win.state().reconcileChildExit(gpa.allocator());
     const should_close = win.state().close_requested.load(.acquire);
     win.state().state_mutex.unlock();
@@ -1240,7 +1348,7 @@ test "window_closing lifecycle message uses grace delay in browser-window mode"
 }
 
 test "window_closing lifecycle pending close cancels on websocket reconnect" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -1276,7 +1384,7 @@ test "window_closing lifecycle pending close cancels on websocket reconnect" {
 }
 
 test "window_closing lifecycle message is ignored in web-url mode without tracked pid" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -1300,7 +1408,7 @@ test "window_closing lifecycle message is ignored in web-url mode without tracke
 }
 
 test "websocket disconnect schedules close in browser-window mode when last client is gone" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -1323,7 +1431,7 @@ test "websocket disconnect schedules close in browser-window mode when last clie
     try std.testing.expect(!close_immediate);
 
     win.state().state_mutex.lock();
-    win.state().lifecycle_close_deadline_ms = std.time.milliTimestamp() - 1;
+    win.state().lifecycle_close_deadline_ms = time_compat.milliTimestamp() - 1;
     win.state().reconcileChildExit(gpa.allocator());
     const should_close = win.state().close_requested.load(.acquire);
     win.state().state_mutex.unlock();
@@ -1331,7 +1439,7 @@ test "websocket disconnect schedules close in browser-window mode when last clie
 }
 
 test "websocket disconnect does not close backend in web-url mode" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -1357,7 +1465,7 @@ test "websocket disconnect does not close backend in web-url mode" {
 test "non-linked tracked browser pid death detaches without close in web mode" {
     if (builtin.os.tag != .linux) return error.SkipZigTest;
 
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -1369,18 +1477,20 @@ test "non-linked tracked browser pid death detaches without close in web mode" {
     try win.showHtml("<html><body>tracked-pid-exit-close</body></html>");
     try app.run();
 
-    var child = std.process.Child.init(&.{ "sh", "-c", "sleep 0.02" }, gpa.allocator());
-    child.stdin_behavior = .Ignore;
-    child.stdout_behavior = .Ignore;
-    child.stderr_behavior = .Ignore;
-    try child.spawn();
+    var child = try std.process.spawn(std.testing.io, .{
+        .argv = &.{ "sh", "-c", "sleep 0.02" },
+        .stdin = .ignore,
+        .stdout = .ignore,
+        .stderr = .ignore,
+    });
+    const child_pid_i64: i64 = @as(i64, @intCast(child.id orelse return error.TestUnexpectedResult));
     defer {
-        std.posix.kill(@as(std.posix.pid_t, @intCast(child.id)), std.posix.SIG.TERM) catch {};
-        _ = child.wait() catch {};
+        std.posix.kill(@as(std.posix.pid_t, @intCast(child_pid_i64)), std.posix.SIG.TERM) catch {};
+        if (child.id != null) _ = child.wait(std.testing.io) catch {};
     }
 
     win.state().state_mutex.lock();
-    win.state().launched_browser_pid = @as(i64, @intCast(child.id));
+    win.state().launched_browser_pid = child_pid_i64;
     win.state().launched_browser_is_child = true;
     win.state().launched_browser_lifecycle_linked = false;
     win.state().state_mutex.unlock();
@@ -1402,7 +1512,7 @@ test "non-linked tracked browser pid death detaches without close in web mode" {
             detached = true;
             break;
         }
-        std.Thread.sleep(5 * std.time.ns_per_ms);
+        time_compat.sleep(5 * std.time.ns_per_ms);
     }
 
     try std.testing.expect(!closed);
@@ -1410,7 +1520,7 @@ test "non-linked tracked browser pid death detaches without close in web mode" {
 }
 
 test "window style apply updates persisted state" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{});
@@ -1451,7 +1561,7 @@ test "window control close handler veto and allow" {
         }
     };
 
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{});
@@ -1481,7 +1591,7 @@ test "close handler may call window api reentrantly" {
         }
     };
 
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{});
@@ -1496,7 +1606,7 @@ test "close handler may call window api reentrantly" {
 }
 
 test "close control remains backend-driven when emulation is disabled" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -1513,7 +1623,7 @@ test "close control remains backend-driven when emulation is disabled" {
 }
 
 test "native backend unavailability returns warnings and falls back to emulation" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -1544,7 +1654,7 @@ test "native backend unavailability returns warnings and falls back to emulation
 }
 
 test "window capability reporting follows fallback policy" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app_default = try App.init(gpa.allocator(), .{
@@ -1568,7 +1678,7 @@ test "window capability reporting follows fallback policy" {
 }
 
 test "window control and style routes roundtrip" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -1605,16 +1715,18 @@ test "window control and style routes roundtrip" {
 
 test "typed rpc registration, invocation, and bridge generation" {
     const DemoRpc = struct {
+        /// Adds two integers for typed RPC registration coverage.
         pub fn sum(a: i64, b: i64) i64 {
             return a + b;
         }
 
+        /// Returns a string payload so bridge generation covers string responses too.
         pub fn ping() []const u8 {
             return "pong";
         }
     };
 
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{});
@@ -1631,11 +1743,11 @@ test "typed rpc registration, invocation, and bridge generation" {
     try std.testing.expect(std.mem.indexOf(u8, script, "globalThis.webuiWindowControl") != null);
     try std.testing.expect(std.mem.indexOf(u8, script, "export default") == null);
 
-    const written_path = try std.fmt.allocPrint(gpa.allocator(), ".zig-cache/test_bridge_written_{d}.js", .{std.time.nanoTimestamp()});
+    const written_path = try std.fmt.allocPrint(gpa.allocator(), ".zig-cache/test_bridge_written_{d}.js", .{time_compat.nanoTimestamp()});
     defer gpa.allocator().free(written_path);
-    defer std.fs.cwd().deleteFile(written_path) catch {};
+    defer std.Io.Dir.cwd().deleteFile(io_compat.io, written_path) catch {};
     try win.rpc().writeGeneratedClientScript(written_path);
-    const written_script = try std.fs.cwd().readFileAlloc(gpa.allocator(), written_path, 1024 * 1024);
+    const written_script = try std.Io.Dir.cwd().readFileAlloc(io_compat.io, written_path, gpa.allocator(), .limited(1024 * 1024));
     defer gpa.allocator().free(written_script);
     try std.testing.expect(std.mem.indexOf(u8, written_script, "async function webuiInvoke(endpoint, name, args)") != null);
 
@@ -1651,6 +1763,7 @@ test "typed rpc registration, invocation, and bridge generation" {
 
 test "rpc event carries client and connection identifiers" {
     const DemoRpc = struct {
+        /// Returns a deterministic reply for the RPC event metadata assertions.
         pub fn ping() []const u8 {
             return "pong";
         }
@@ -1673,7 +1786,7 @@ test "rpc event carries client and connection identifiers" {
     Capture.client_id = null;
     Capture.connection_id = null;
 
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -1704,12 +1817,13 @@ test "rpc event carries client and connection identifiers" {
 
 test "friendly service api with compile-time rpc_methods constant" {
     const rpc_methods = struct {
+        /// Returns the service-level ping value used by the compile-time bridge smoke test.
         pub fn ping() []const u8 {
             return "pong";
         }
     };
 
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var service = try Service.init(gpa.allocator(), rpc_methods, .{
@@ -1739,12 +1853,13 @@ test "friendly service api with compile-time rpc_methods constant" {
 
 test "threaded dispatcher executes rpc on worker queue" {
     const DemoRpc = struct {
+        /// Multiplies two integers so the threaded dispatcher can be validated with a simple pure function.
         pub fn mul(a: i64, b: i64) i64 {
             return a * b;
         }
     };
 
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{});
@@ -1765,6 +1880,7 @@ test "threaded dispatcher executes rpc on worker queue" {
 
 test "custom dispatcher can wrap default invoker" {
     const DemoRpc = struct {
+        /// Returns a simple string value so the custom dispatcher path can wrap the default invoker.
         pub fn ping() []const u8 {
             return "pong";
         }
@@ -1782,7 +1898,7 @@ test "custom dispatcher can wrap default invoker" {
         }
     };
 
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{});
@@ -1803,10 +1919,12 @@ test "custom dispatcher can wrap default invoker" {
 
 test "comptime bridge generation" {
     const DemoRpc = struct {
+        /// Returns a ping value so the generated bridge includes a zero-argument string-returning RPC.
         pub fn ping() []const u8 {
             return "pong";
         }
 
+        /// Adds two integers so the generated bridge includes a multi-argument numeric RPC.
         pub fn sum(a: i64, b: i64) i64 {
             return a + b;
         }
@@ -1839,7 +1957,7 @@ test "runtime helper exposes window style/control and frontend rpc helpers" {
 }
 
 test "raw channel callback" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{});
@@ -1860,7 +1978,7 @@ test "raw channel callback" {
 }
 
 test "evalScript times out when no client is polling" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -1884,7 +2002,7 @@ test "evalScript times out when no client is polling" {
 }
 
 test "callFrontend fire-and-forget queues targeted ws frontend rpc task" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -1910,7 +2028,7 @@ test "callFrontend fire-and-forget queues targeted ws frontend rpc task" {
 }
 
 test "callFrontend await on selected connections returns per-connection results" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -1943,7 +2061,7 @@ test "callFrontend await on selected connections returns per-connection results"
 }
 
 test "callFrontend all requires active ws connections" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -1960,7 +2078,7 @@ test "callFrontend all requires active ws connections" {
 }
 
 test "script response websocket message completes queued eval task" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -2000,7 +2118,7 @@ test "script response websocket message completes queued eval task" {
 }
 
 test "frontend rpc response websocket message completes queued frontend task" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -2039,8 +2157,60 @@ test "frontend rpc response websocket message completes queued frontend task" {
     task.deinit();
 }
 
+test "websocket messages ignore invalid numeric ids without trapping" {
+    var gpa = std.heap.DebugAllocator(.{}){};
+    defer _ = gpa.deinit();
+
+    var app = try App.init(gpa.allocator(), .{
+        .launch_policy = .{ .first = .web_url, .second = null, .third = null },
+    });
+    defer app.deinit();
+
+    var win = try app.newWindow(.{ .title = "InvalidWsIds" });
+    try win.showHtml("<html><body>invalid-ws-ids</body></html>");
+    try app.run();
+
+    const state = win.state();
+
+    state.state_mutex.lock();
+    state.last_close_ack_id = 9;
+    const script_task = try state.queueScriptLocked(gpa.allocator(), "return 1;", null, true);
+    try std.testing.expect(state.removeScriptPendingLocked(script_task));
+    try state.script_inflight.append(script_task);
+    const frontend_task = try state.queueFrontendRpcLocked(gpa.allocator(), "ui.echo", "[\"abc\"]", null, true);
+    try std.testing.expect(state.removeFrontendRpcPendingLocked(frontend_task));
+    try state.frontend_rpc_inflight.append(frontend_task);
+    state.state_mutex.unlock();
+
+    try state.handleWebSocketClientMessage(1, "{\"type\":\"close_ack\",\"id\":-1}");
+    try state.handleWebSocketClientMessage(1, "{\"type\":\"frontend_rpc_response\",\"id\":1.5,\"js_error\":false,\"value\":\"bad\"}");
+    try state.handleWebSocketClientMessage(1, "{\"type\":\"script_response\",\"id\":-7,\"js_error\":false,\"value\":99}");
+
+    state.state_mutex.lock();
+    const close_ack_id = state.last_close_ack_id;
+    state.state_mutex.unlock();
+    try std.testing.expectEqual(@as(u64, 9), close_ack_id);
+
+    script_task.mutex.lock();
+    const script_done = script_task.done;
+    script_task.mutex.unlock();
+    try std.testing.expect(!script_done);
+
+    frontend_task.mutex.lock();
+    const frontend_done = frontend_task.done;
+    frontend_task.mutex.unlock();
+    try std.testing.expect(!frontend_done);
+
+    state.state_mutex.lock();
+    _ = state.removeScriptInflightLocked(script_task);
+    _ = state.removeFrontendRpcInflightLocked(frontend_task);
+    state.state_mutex.unlock();
+    script_task.deinit();
+    frontend_task.deinit();
+}
+
 test "runtime render state and capability probe expose launch policy selection" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -2085,7 +2255,7 @@ test "diagnostic callback emits typed transport diagnostics" {
     Capture.saw_transport = false;
     Capture.saw_fallback = false;
 
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -2113,12 +2283,13 @@ test "service init keeps diagnostic callback binding invariant stable" {
     };
 
     const rpc_methods = struct {
+        /// Returns the baseline ping value for service-init invariant coverage.
         pub fn ping() []const u8 {
             return "pong";
         }
     };
 
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var service = try Service.init(gpa.allocator(), rpc_methods, .{
@@ -2145,12 +2316,13 @@ test "service move is detected by diagnostic callback binding invariant" {
     };
 
     const rpc_methods = struct {
+        /// Returns the baseline ping value for moved-service invariant coverage.
         pub fn ping() []const u8 {
             return "pong";
         }
     };
 
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var service = try Service.init(gpa.allocator(), rpc_methods, .{
@@ -2193,12 +2365,13 @@ test "service move guard emits typed diagnostic on mismatch" {
     Capture.saw_severity = false;
 
     const rpc_methods = struct {
+        /// Returns the baseline ping value for the moved-service diagnostic event assertions.
         pub fn ping() []const u8 {
             return "pong";
         }
     };
 
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var service = try Service.init(gpa.allocator(), rpc_methods, .{
@@ -2234,12 +2407,13 @@ test "normal service flow does not emit pinned move diagnostics" {
     Capture.pinned_count = 0;
 
     const rpc_methods = struct {
+        /// Returns the baseline ping value for the non-moved service flow.
         pub fn ping() []const u8 {
             return "pong";
         }
     };
 
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var service = try Service.init(gpa.allocator(), rpc_methods, .{
@@ -2261,12 +2435,13 @@ test "normal service flow does not emit pinned move diagnostics" {
 
 test "service requirement listing and probe are available before show" {
     const rpc_methods = struct {
+        /// Returns the baseline ping value for runtime requirement probing.
         pub fn ping() []const u8 {
             return "pong";
         }
     };
 
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var service = try Service.init(gpa.allocator(), rpc_methods, .{
@@ -2302,12 +2477,13 @@ test "linux webview target selection is reflected in runtime requirements" {
     if (builtin.os.tag != .linux) return;
 
     const rpc_methods = struct {
+        /// Returns the baseline ping value for Linux runtime requirement selection coverage.
         pub fn ping() []const u8 {
             return "pong";
         }
     };
 
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var service = try Service.init(gpa.allocator(), rpc_methods, .{
@@ -2337,14 +2513,15 @@ test "linux webview target selection is reflected in runtime requirements" {
 
 test "rpc route returns value directly with threaded default dispatcher" {
     const DemoRpc = struct {
+        /// Sleeps for the requested delay before returning the sum to exercise threaded RPC response delivery.
         pub fn delayedAdd(a: i64, b: i64, delay_ms: i64) i64 {
             const delay = if (delay_ms < 0) @as(u64, 0) else @as(u64, @intCast(delay_ms));
-            std.Thread.sleep(delay * std.time.ns_per_ms);
+            time_compat.sleep(delay * std.time.ns_per_ms);
             return a + b;
         }
     };
 
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -2377,15 +2554,16 @@ test "rpc route returns value directly with threaded default dispatcher" {
 
 test "threaded dispatcher stress handles concurrent http rpc requests" {
     const DemoRpc = struct {
+        /// Multiplies inputs after a short delay so concurrent dispatcher work overlaps in the stress test.
         pub fn mul(a: i64, b: i64) i64 {
-            std.Thread.sleep(std.time.ns_per_ms);
+            time_compat.sleep(std.time.ns_per_ms);
             return a * b;
         }
     };
 
     const Shared = struct { failed: std.atomic.Value(bool) = std.atomic.Value(bool).init(false) };
 
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -2414,7 +2592,7 @@ test "threaded dispatcher stress handles concurrent http rpc requests" {
     };
     const Worker = struct {
         fn run(ctx: *Ctx) void {
-            var gpa_thread = std.heap.GeneralPurposeAllocator(.{}){};
+            var gpa_thread = std.heap.DebugAllocator(.{}){};
             defer _ = gpa_thread.deinit();
             const allocator = gpa_thread.allocator();
 
@@ -2476,20 +2654,23 @@ test "rpc flat contract supports structured args and object/array returns" {
             value: i64,
         };
 
+        /// Scores a structured payload to validate direct typed argument decoding for object arguments.
         pub fn score(payload: Payload) i64 {
             return payload.a + (payload.b orelse 0) + (if (payload.mode == .fast) @as(i64, 1) else @as(i64, 2));
         }
 
+        /// Returns a structured object to verify flat object responses on the RPC route.
         pub fn obj() Out {
             return .{ .ok = true, .value = 9 };
         }
 
+        /// Returns an array payload to verify flat array responses on the RPC route.
         pub fn arr() [3]i64 {
             return .{ 1, 2, 3 };
         }
     };
 
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
@@ -2519,16 +2700,18 @@ test "rpc flat contract supports structured args and object/array returns" {
 
 test "rpc errors map to status code with empty body" {
     const DemoRpc = struct {
+        /// Adds two integers for successful flat-contract status assertions.
         pub fn add(a: i64, b: i64) i64 {
             return a + b;
         }
 
+        /// Always fails so the RPC route can assert empty-body error status mapping.
         pub fn boom() !i64 {
             return error.Boom;
         }
     };
 
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
 
     var app = try App.init(gpa.allocator(), .{
diff --git a/src/root/window.zig b/src/root/window.zig
index 23a68b8..845115e 100644
--- a/src/root/window.zig
+++ b/src/root/window.zig
@@ -4,6 +4,8 @@ const builtin = @import("builtin");
 const app_mod = @import("app.zig");
 const rpc_registry_mod = @import("rpc_registry.zig");
 const core_runtime = @import("../ported/webui.zig");
+const time_compat = @import("time_compat");
+const io_compat = @import("io_compat");
 const launch_policy = @import("launch_policy.zig");
 const api_types = @import("api_types.zig");
 const root_utils = @import("utils.zig");
@@ -51,13 +53,16 @@ pub fn pinnedMoveGuardEnabled() bool {
 
 /// Represents a single WebUI window and its associated runtime state.
 pub const Window = struct {
+    /// Stores the app.
     app: *App,
+    /// Stores the index.
     index: usize,
+    /// Stores the id.
     id: usize,
 
     fn refreshRenderedContentLocked(self: *Window, win_state: *WindowState) !void {
         try win_state.ensureBrowserRenderState(self.app.allocator, self.app.options);
-        if (win_state.isNativeWindowActive() and win_state.backend.isReady()) {
+        if (win_state.isNativeWindowActive()) {
             if (win_state.last_url) |url| {
                 try win_state.backend.showContent(.{ .url = url });
             }
@@ -101,7 +106,7 @@ pub const Window = struct {
         self.app.enforcePinnedMoveInvariant(.app);
         if (path.len == 0) return error.EmptyPath;
 
-        _ = try std.fs.cwd().statFile(path);
+        _ = try std.Io.Dir.cwd().statFile(io_compat.io, path, .{});
 
         const win_state = self.state();
 
@@ -142,19 +147,12 @@ pub const Window = struct {
         }
         win_state.shown = true;
 
-        if (win_state.isNativeWindowActive() and win_state.backend.isReady()) {
+        if (win_state.isNativeWindowActive()) {
             try win_state.backend.showContent(.{ .url = url });
         }
 
         if (!builtin.is_test and win_state.shouldAttemptBrowserSpawnLocked(self.app.allocator, false)) {
-            const launch_options = win_state.effectiveBrowserLaunchOptions(self.app.options.browser_launch);
-            if (core_runtime.openInBrowser(self.app.allocator, url, win_state.current_style, launch_options)) |launch| {
-                win_state.setLaunchedBrowserLaunch(self.app.allocator, launch);
-            } else |err| {
-                _ = try win_state.advanceAfterBrowserLaunchFailureLocked(win_state.runtime_render_state.active_surface);
-                win_state.rpc_state.logf(.warn, "[webui.browser] launch failed error={s}\n", .{@errorName(err)});
-                if (win_state.runtime_render_state.active_surface == .browser_window and win_state.launch_policy.app_mode_required) return err;
-            }
+            _ = try win_state.launchBrowserSurfaceWithFallbackLocked(self.app.allocator, self.app.options, false);
         }
 
         self.emitRuntimeDiagnostics();
@@ -214,10 +212,15 @@ pub const Window = struct {
 
     /// Invokes a frontend function on one target and waits for a result.
     pub fn callFrontend(
+        /// Stores the self.
         self: *Window,
+        /// Stores the allocator.
         allocator: std.mem.Allocator,
+        /// Stores the function name.
         function_name: []const u8,
+        /// Stores the args.
         args: anytype,
+        /// Stores the options.
         options: ScriptOptions,
     ) !ScriptEvalResult {
         if (function_name.len == 0) return error.EmptyFrontendFunctionName;
@@ -244,9 +247,13 @@ pub const Window = struct {
 
     /// Invokes a frontend function without waiting for a result.
     pub fn callFrontendFireAndForget(
+        /// Stores the self.
         self: *Window,
+        /// Stores the function name.
         function_name: []const u8,
+        /// Stores the args.
         args: anytype,
+        /// Stores the options.
         options: ScriptOptions,
     ) !void {
         if (function_name.len == 0) return error.EmptyFrontendFunctionName;
@@ -271,9 +278,13 @@ pub const Window = struct {
 
     /// Invokes a frontend function on a specific set of websocket connections.
     pub fn callFrontendOnConnections(
+        /// Stores the self.
         self: *Window,
+        /// Stores the function name.
         function_name: []const u8,
+        /// Stores the args.
         args: anytype,
+        /// Stores the connection ids.
         connection_ids: []const usize,
     ) !void {
         if (connection_ids.len == 0) return error.NoTargetConnections;
@@ -305,11 +316,17 @@ pub const Window = struct {
 
     /// Invokes a frontend function on specific connections and waits for all results.
     pub fn callFrontendAwaitConnections(
+        /// Stores the self.
         self: *Window,
+        /// Stores the allocator.
         allocator: std.mem.Allocator,
+        /// Stores the function name.
         function_name: []const u8,
+        /// Stores the args.
         args: anytype,
+        /// Stores the connection ids.
         connection_ids: []const usize,
+        /// Stores the timeout ms.
         timeout_ms: ?u32,
     ) ![]FrontendCallResult {
         if (connection_ids.len == 0) return error.NoTargetConnections;
@@ -369,10 +386,15 @@ pub const Window = struct {
 
     /// Invokes a frontend function on all connected websocket clients and waits for all results.
     pub fn callFrontendAwaitAll(
+        /// Stores the self.
         self: *Window,
+        /// Stores the allocator.
         allocator: std.mem.Allocator,
+        /// Stores the function name.
         function_name: []const u8,
+        /// Stores the args.
         args: anytype,
+        /// Stores the timeout ms.
         timeout_ms: ?u32,
     ) ![]FrontendCallResult {
         const connection_ids = try self.snapshotConnectedConnectionIds(allocator);
@@ -382,9 +404,13 @@ pub const Window = struct {
 
     /// Evaluates JavaScript on the frontend and waits for a result.
     pub fn evalScript(
+        /// Stores the self.
         self: *Window,
+        /// Stores the allocator.
         allocator: std.mem.Allocator,
+        /// Stores the script.
         script: []const u8,
+        /// Stores the options.
         options: ScriptOptions,
     ) !ScriptEvalResult {
         if (script.len == 0) return error.EmptyScript;
@@ -403,10 +429,15 @@ pub const Window = struct {
     }
 
     fn awaitScriptTaskResult(
+        /// Stores the self.
         self: *Window,
+        /// Stores the allocator.
         allocator: std.mem.Allocator,
+        /// Stores the win state.
         win_state: *WindowState,
+        /// Stores the task.
         task: *ScriptTask,
+        /// Stores the timeout ms.
         timeout_ms: ?u32,
     ) !ScriptEvalResult {
         var timed_out = false;
@@ -414,9 +445,9 @@ pub const Window = struct {
 
         if (timeout_ms) |timeout| {
             const timeout_ns: u64 = @as(u64, timeout) * std.time.ns_per_ms;
-            const deadline = std.time.nanoTimestamp() + @as(i128, @intCast(timeout_ns));
+            const deadline = time_compat.nanoTimestamp() + @as(i128, @intCast(timeout_ns));
             while (!task.done) {
-                const now = std.time.nanoTimestamp();
+                const now = time_compat.nanoTimestamp();
                 if (now >= deadline) {
                     timed_out = true;
                     break;
@@ -457,10 +488,15 @@ pub const Window = struct {
     }
 
     fn awaitFrontendRpcTaskResult(
+        /// Stores the self.
         self: *Window,
+        /// Stores the allocator.
         allocator: std.mem.Allocator,
+        /// Stores the win state.
         win_state: *WindowState,
+        /// Stores the task.
         task: *FrontendRpcTask,
+        /// Stores the timeout ms.
         timeout_ms: ?u32,
     ) !ScriptEvalResult {
         var timed_out = false;
@@ -468,9 +504,9 @@ pub const Window = struct {
 
         if (timeout_ms) |timeout| {
             const timeout_ns: u64 = @as(u64, timeout) * std.time.ns_per_ms;
-            const deadline = std.time.nanoTimestamp() + @as(i128, @intCast(timeout_ns));
+            const deadline = time_compat.nanoTimestamp() + @as(i128, @intCast(timeout_ns));
             while (!task.done) {
-                const now = std.time.nanoTimestamp();
+                const now = time_compat.nanoTimestamp();
                 if (now >= deadline) {
                     timed_out = true;
                     break;
@@ -572,13 +608,16 @@ pub const Window = struct {
 
         const launch = try core_runtime.openInBrowser(self.app.allocator, url, win_state.current_style, launch_options);
         win_state.setLaunchedBrowserLaunch(self.app.allocator, launch);
+        win_state.verifyBrowserAttachedLocked(self.app.allocator) catch |err| {
+            if (win_state.retryUrlAttachFallbackLocked(self.app.allocator)) return;
+            win_state.clearTrackedBrowserState(self.app.allocator);
+            return err;
+        };
     }
 
     /// Applies native window style changes.
     pub fn applyStyle(self: *Window, style: WindowStyle) !void {
         const win_state = self.state();
-        win_state.state_mutex.lock();
-        defer win_state.state_mutex.unlock();
         try win_state.applyStyle(self.app.allocator, style);
     }
 
@@ -617,8 +656,6 @@ pub const Window = struct {
     /// Sends a native window control command.
     pub fn control(self: *Window, cmd: WindowControl) !WindowControlResult {
         const win_state = self.state();
-        win_state.state_mutex.lock();
-        defer win_state.state_mutex.unlock();
         return win_state.control(cmd);
     }
 
diff --git a/src/root/window_state.zig b/src/root/window_state.zig
index b54a1bc..cb52a6e 100644
--- a/src/root/window_state.zig
+++ b/src/root/window_state.zig
@@ -12,6 +12,9 @@ const rpc_runtime = @import("rpc_runtime.zig");
 const root_utils = @import("utils.zig");
 const net_io = @import("net_io.zig");
 const server_routes = @import("server_routes.zig");
+const thread_compat = @import("thread_compat");
+const time_compat = @import("time_compat");
+const io_compat = @import("io_compat");
 
 const LaunchPolicy = api_types.LaunchPolicy;
 const LaunchSurface = api_types.LaunchSurface;
@@ -42,26 +45,42 @@ const launchPolicyNextAfter = launch_policy.nextAfter;
 
 const replaceOwned = root_utils.replaceOwned;
 const isHttpUrl = root_utils.isHttpUrl;
+pub const browser_attach_timeout_ms_web_url: u32 = if (builtin.is_test) 50 else 2_000;
+pub const browser_attach_timeout_ms_browser_window: u32 = if (builtin.is_test) 50 else 1_250;
+const browser_attach_poll_ns: u64 = 25 * std.time.ns_per_ms;
+const native_ui_task_wait_timeout_ns: u64 = 5 * std.time.ns_per_s;
 
+/// Stores event callback state.
 pub const EventCallbackState = struct {
+    /// Stores the handler.
     handler: ?EventHandler = null,
+    /// Stores the context.
     context: ?*anyopaque = null,
 };
 
 pub const DiagnosticHandler = *const fn (context: ?*anyopaque, diagnostic: *const Diagnostic) void;
 
+/// Stores diagnostic callback state.
 pub const DiagnosticCallbackState = struct {
+    /// Stores the handler.
     handler: ?DiagnosticHandler = null,
+    /// Stores the context.
     context: ?*anyopaque = null,
 };
 
+/// Stores raw callback state.
 pub const RawCallbackState = struct {
+    /// Stores the handler.
     handler: ?RawHandler = null,
+    /// Stores the context.
     context: ?*anyopaque = null,
 };
 
+/// Stores close callback state.
 pub const CloseCallbackState = struct {
+    /// Stores the handler.
     handler: ?CloseHandler = null,
+    /// Stores the context.
     context: ?*anyopaque = null,
 };
 
@@ -89,33 +108,56 @@ fn backendWarningForError(err: anyerror, will_fallback: bool) ?[]const u8 {
 
 const RpcRegistryState = rpc_runtime.State;
 
+/// Stores client session.
 pub const ClientSession = struct {
+    /// Stores the token.
     token: []u8,
+    /// Stores the client id.
     client_id: usize,
+    /// Stores the connection id.
     connection_id: usize,
+    /// Stores the last seen ms.
     last_seen_ms: i64,
 };
 
+/// Stores script task.
 pub const ScriptTask = struct {
+    /// Stores the allocator.
     allocator: std.mem.Allocator,
+    /// Stores the id.
     id: u64,
+    /// Stores the target connection.
     target_connection: ?usize,
+    /// Stores the script.
     script: []u8,
+    /// Stores the expect result.
     expect_result: bool,
+    /// Stores the done.
     done: bool = false,
+    /// Stores the timed out.
     timed_out: bool = false,
+    /// Stores the js error.
     js_error: bool = false,
+    /// Stores the value json.
     value_json: ?[]u8 = null,
+    /// Stores the error message.
     error_message: ?[]u8 = null,
-    mutex: std.Thread.Mutex = .{},
-    cond: std.Thread.Condition = .{},
+    /// Stores the mutex.
+    mutex: thread_compat.Mutex = .{},
+    /// Stores the cond.
+    cond: thread_compat.Condition = .{},
 
     /// Initializes this value.
     pub fn init(
+        /// Stores the allocator.
         allocator: std.mem.Allocator,
+        /// Stores the id.
         id: u64,
+        /// Stores the script.
         script: []const u8,
+        /// Stores the target connection.
         target_connection: ?usize,
+        /// Stores the expect result.
         expect_result: bool,
     ) !*ScriptTask {
         const task = try allocator.create(ScriptTask);
@@ -138,28 +180,48 @@ pub const ScriptTask = struct {
     }
 };
 
+/// Stores frontend rpc task.
 pub const FrontendRpcTask = struct {
+    /// Stores the allocator.
     allocator: std.mem.Allocator,
+    /// Stores the id.
     id: u64,
+    /// Stores the target connection.
     target_connection: ?usize,
+    /// Stores the function name.
     function_name: []u8,
+    /// Stores the args json.
     args_json: []u8,
+    /// Stores the expect result.
     expect_result: bool,
+    /// Stores the done.
     done: bool = false,
+    /// Stores the timed out.
     timed_out: bool = false,
+    /// Stores the js error.
     js_error: bool = false,
+    /// Stores the value json.
     value_json: ?[]u8 = null,
+    /// Stores the error message.
     error_message: ?[]u8 = null,
-    mutex: std.Thread.Mutex = .{},
-    cond: std.Thread.Condition = .{},
+    /// Stores the mutex.
+    mutex: thread_compat.Mutex = .{},
+    /// Stores the cond.
+    cond: thread_compat.Condition = .{},
 
     /// Initializes this value.
     pub fn init(
+        /// Stores the allocator.
         allocator: std.mem.Allocator,
+        /// Stores the id.
         id: u64,
+        /// Stores the function name.
         function_name: []const u8,
+        /// Stores the args json.
         args_json: []const u8,
+        /// Stores the target connection.
         target_connection: ?usize,
+        /// Stores the expect result.
         expect_result: bool,
     ) !*FrontendRpcTask {
         const task = try allocator.create(FrontendRpcTask);
@@ -184,19 +246,80 @@ pub const FrontendRpcTask = struct {
     }
 };
 
+const NativeUiTask = struct {
+    const Kind = union(enum) {
+        apply_style: WindowStyle,
+        control: WindowControl,
+    };
+
+    kind: Kind,
+    completion_owned_by_waiter: bool = false,
+    done: bool = false,
+    err: ?anyerror = null,
+    mutex: thread_compat.Mutex = .{},
+    cond: thread_compat.Condition = .{},
+
+    fn init(allocator: std.mem.Allocator, kind: Kind) !*NativeUiTask {
+        const task = try allocator.create(NativeUiTask);
+        task.* = .{ .kind = kind };
+        return task;
+    }
+
+    fn deinit(self: *NativeUiTask, allocator: std.mem.Allocator) void {
+        allocator.destroy(self);
+    }
+};
+
+fn waitForNativeUiTaskCompletion(task: *NativeUiTask, timeout_ns: u64, quantum_ns: u64) bool {
+    const wait_quantum_ns = if (quantum_ns == 0) timeout_ns else @min(timeout_ns, quantum_ns);
+    const deadline = time_compat.nanoTimestamp() + @as(i128, @intCast(timeout_ns));
+
+    while (!task.done) {
+        const now = time_compat.nanoTimestamp();
+        if (now >= deadline) break;
+
+        const remaining_ns: u64 = @intCast(deadline - now);
+        const wait_ns = if (wait_quantum_ns == 0) remaining_ns else @min(remaining_ns, wait_quantum_ns);
+        task.cond.timedWait(&task.mutex, wait_ns) catch {};
+    }
+
+    return task.done;
+}
+
+const RuntimeBrowserLauncher = struct {
+    fn open(
+        _: *RuntimeBrowserLauncher,
+        allocator: std.mem.Allocator,
+        url: []const u8,
+        style: WindowStyle,
+        launch_options: BrowserLaunchOptions,
+    ) !core_runtime.BrowserLaunch {
+        return core_runtime.openInBrowser(allocator, url, style, launch_options);
+    }
+};
+
 pub const default_client_token = "default-client";
 
+/// Represents ws transport variants.
 pub const WsTransport = union(enum) {
-    plain: std.net.Stream,
+    /// Stores the plain.
+    plain: std.Io.net.Stream,
+    /// Stores the tls.
     tls: *https_server.Connection,
 
     /// Reads bytes from this transport.
     pub fn read(self: *WsTransport, buffer: []u8) !usize {
         return switch (self.*) {
-            .plain => |stream| if (builtin.os.tag == .windows)
-                std.posix.recv(stream.handle, buffer, 0)
-            else
-                stream.read(buffer),
+            .plain => |stream| blk: {
+                var read_buf: [0]u8 = .{};
+                var reader = stream.reader(io_compat.io, &read_buf);
+                var vec = [_][]u8{buffer};
+                const n = reader.interface.readVec(&vec) catch |err| switch (err) {
+                    error.EndOfStream => 0,
+                    error.ReadFailed => return reader.err orelse error.Closed,
+                };
+                break :blk n;
+            },
             .tls => |conn| conn.read(buffer),
         };
     }
@@ -204,21 +327,19 @@ pub const WsTransport = union(enum) {
     /// Writes all bytes to this transport.
     pub fn writeAll(self: *WsTransport, bytes: []const u8) !void {
         return switch (self.*) {
-            .plain => |stream| if (builtin.os.tag == .windows) blk: {
-                var offset: usize = 0;
-                while (offset < bytes.len) {
-                    const n = std.posix.send(stream.handle, bytes[offset..], 0) catch |err| switch (err) {
-                        error.WouldBlock => {
-                            std.Thread.sleep(std.time.ns_per_ms);
-                            continue;
-                        },
-                        else => return err,
-                    };
-                    if (n == 0) return error.Closed;
-                    offset += n;
-                }
+            .plain => |stream| blk: {
+                var write_buf: [1024]u8 = undefined;
+                var writer = stream.writer(io_compat.io, &write_buf);
+                writer.interface.writeAll(bytes) catch |err| {
+                    if (err == error.WriteFailed) return writer.err orelse error.Closed;
+                    return err;
+                };
+                writer.interface.flush() catch |err| {
+                    if (err == error.WriteFailed) return writer.err orelse error.Closed;
+                    return err;
+                };
                 break :blk;
-            } else stream.writeAll(bytes),
+            },
             .tls => |conn| conn.writeAll(bytes),
         };
     }
@@ -226,7 +347,7 @@ pub const WsTransport = union(enum) {
     /// Shuts down this transport.
     pub fn shutdown(self: *WsTransport) void {
         switch (self.*) {
-            .plain => |stream| std.posix.shutdown(stream.handle, .both) catch {},
+            .plain => |stream| stream.shutdown(io_compat.io, .both) catch {},
             .tls => |conn| {
                 conn.close();
             },
@@ -243,74 +364,144 @@ pub const WsTransport = union(enum) {
     }
 };
 
+/// Stores ws connection state.
 pub const WsConnectionState = struct {
+    /// Stores the connection id.
     connection_id: usize,
+    /// Stores the generation.
     generation: u64,
+    /// Stores the transport.
     transport: WsTransport,
 };
 
+/// Stores window state.
 pub const WindowState = struct {
+    /// Stores the allocator.
     allocator: std.mem.Allocator,
+    /// Stores the id.
     id: usize,
+    /// Stores the title.
     title: []u8,
+    /// Stores the diagnostic callback.
     diagnostic_callback: *DiagnosticCallbackState,
+    /// Stores the launch policy.
     launch_policy: LaunchPolicy,
+    /// Stores the runtime render state.
     runtime_render_state: RuntimeRenderState,
+    /// Stores the window fallback emulation.
     window_fallback_emulation: bool,
+    /// Stores the server port.
     server_port: u16,
+    /// Whether server tls enabled.
     server_tls_enabled: bool,
+    /// Stores the server tls cert pem.
     server_tls_cert_pem: ?[]const u8,
+    /// Stores the server tls key pem.
     server_tls_key_pem: ?[]const u8,
+    /// Stores the server bind public.
     server_bind_public: bool,
+    /// Stores the last html.
     last_html: ?[]u8,
+    /// Stores the last file.
     last_file: ?[]u8,
+    /// Stores the last url.
     last_url: ?[]u8,
+    /// Stores the shown.
     shown: bool,
-    connected_emitted: bool,
+    /// Stores the startup events emitted.
+    startup_events_emitted: bool,
+    /// Stores the frontend connected.
+    frontend_connected: bool,
+    /// Stores the event callback.
     event_callback: EventCallbackState,
+    /// Stores the raw callback.
     raw_callback: RawCallbackState,
+    /// Stores the close callback.
     close_callback: CloseCallbackState,
+    /// Stores the rpc state.
     rpc_state: RpcRegistryState,
+    /// Stores the backend.
     backend: webview_backend.NativeBackend,
+    /// Stores the native capabilities.
     native_capabilities: []const WindowCapability,
+    /// Stores the current style.
     current_style: WindowStyle,
+    /// Stores the style icon bytes.
     style_icon_bytes: ?[]u8,
+    /// Stores the style icon mime.
     style_icon_mime: ?[]u8,
+    /// Stores the launched browser pid.
     launched_browser_pid: ?i64,
+    /// Stores the launched browser kind.
     launched_browser_kind: ?browser_discovery.BrowserKind,
+    /// Stores the launched browser is child.
     launched_browser_is_child: bool,
+    /// Stores the launched browser lifecycle linked.
     launched_browser_lifecycle_linked: bool,
+    /// Stores the launched browser profile dir.
     launched_browser_profile_dir: ?[]u8,
+    /// Stores the launched browser profile ownership.
     launched_browser_profile_ownership: BrowserLaunchProfileOwnership,
+    /// Stores the last warning.
     last_warning: ?[]const u8,
+    /// Tracks the next client id.
     next_client_id: usize,
+    /// Tracks the next connection id.
     next_connection_id: usize,
+    /// Tracks the next ws generation.
     next_ws_generation: u64,
+    /// Stores the client sessions.
     client_sessions: std.array_list.Managed(ClientSession),
+    /// Tracks the next script id.
     next_script_id: u64,
+    /// Stores the script pending.
     script_pending: std.array_list.Managed(*ScriptTask),
+    /// Stores the script inflight.
     script_inflight: std.array_list.Managed(*ScriptTask),
+    /// Tracks the next frontend rpc id.
     next_frontend_rpc_id: u64,
+    /// Stores the frontend rpc pending.
     frontend_rpc_pending: std.array_list.Managed(*FrontendRpcTask),
+    /// Stores the frontend rpc inflight.
     frontend_rpc_inflight: std.array_list.Managed(*FrontendRpcTask),
+    /// Tracks the next close signal id.
     next_close_signal_id: u64,
+    /// Stores the last close ack id.
     last_close_ack_id: u64,
-    close_ack_cond: std.Thread.Condition,
+    /// Coordinates access to the close ack.
+    close_ack_cond: thread_compat.Condition,
+    /// Stores the lifecycle close pending.
     lifecycle_close_pending: bool,
+    /// Stores the lifecycle close deadline ms.
     lifecycle_close_deadline_ms: i64,
+    /// Stores the native ui pending.
+    native_ui_pending: std.array_list.Managed(*NativeUiTask),
+    /// Stores the ws connections.
     ws_connections: std.array_list.Managed(WsConnectionState),
 
-    state_mutex: std.Thread.Mutex,
-    connection_mutex: std.Thread.Mutex,
-    connection_cond: std.Thread.Condition,
+    /// Coordinates access to the state.
+    state_mutex: thread_compat.Mutex,
+    /// Coordinates access to the connection.
+    connection_mutex: thread_compat.Mutex,
+    /// Coordinates access to the connection.
+    connection_cond: thread_compat.Condition,
+    /// Stores the active connection workers.
     active_connection_workers: usize,
+    /// Stores the active ws workers.
     active_ws_workers: usize,
+    /// Owns the server thread.
     server_thread: ?std.Thread,
+    /// Stores the server stop.
     server_stop: std.atomic.Value(bool),
-    server_ready_mutex: std.Thread.Mutex,
-    server_ready_cond: std.Thread.Condition,
+    /// Coordinates access to the server ready.
+    server_ready_mutex: thread_compat.Mutex,
+    /// Coordinates access to the server ready.
+    server_ready_cond: thread_compat.Condition,
+    /// Stores the server ready.
     server_ready: bool,
+    /// Stores the server listen ok.
     server_listen_ok: bool,
+    /// Stores the close requested.
     close_requested: std.atomic.Value(bool),
 
     const emulated_capabilities = [_]WindowCapability{
@@ -327,10 +518,15 @@ pub const WindowState = struct {
 
     /// Initializes this value.
     pub fn init(
+        /// Stores the allocator.
         allocator: std.mem.Allocator,
+        /// Stores the id.
         id: usize,
+        /// Stores the options.
         options: WindowOptions,
+        /// Stores the app options.
         app_options: AppOptions,
+        /// Stores the diagnostic callback.
         diagnostic_callback: *DiagnosticCallbackState,
     ) !WindowState {
         var state: WindowState = .{
@@ -358,7 +554,8 @@ pub const WindowState = struct {
             .last_file = null,
             .last_url = null,
             .shown = false,
-            .connected_emitted = false,
+            .startup_events_emitted = false,
+            .frontend_connected = false,
             .event_callback = .{},
             .raw_callback = .{},
             .close_callback = .{},
@@ -393,6 +590,7 @@ pub const WindowState = struct {
             .close_ack_cond = .{},
             .lifecycle_close_pending = false,
             .lifecycle_close_deadline_ms = 0,
+            .native_ui_pending = std.array_list.Managed(*NativeUiTask).init(allocator),
             .ws_connections = std.array_list.Managed(WsConnectionState).init(allocator),
             .state_mutex = .{},
             .connection_mutex = .{},
@@ -593,6 +791,13 @@ pub const WindowState = struct {
 
     /// Applies style changes to the active backend or fallback surface.
     pub fn applyStyle(self: *WindowState, allocator: std.mem.Allocator, style: WindowStyle) !void {
+        self.state_mutex.lock();
+        defer self.state_mutex.unlock();
+        try self.applyStyleLocked(allocator, style);
+    }
+
+    /// Applies style changes to the active backend or fallback surface while holding `state_mutex`.
+    fn applyStyleLocked(self: *WindowState, allocator: std.mem.Allocator, style: WindowStyle) !void {
         try self.setStyleOwned(allocator, style);
         self.clearWarning();
         if (self.isNativeWindowActive()) {
@@ -604,6 +809,11 @@ pub const WindowState = struct {
                 return error.UnsupportedWindowStyle;
             }
             self.backend.applyStyle(self.current_style) catch |err| {
+                if (err == error.NativeThreadAffinityViolation) {
+                    try self.dispatchNativeUiTaskLocked(.{ .apply_style = self.current_style });
+                    self.emit(.window_state, "style-native", "applied");
+                    return;
+                }
                 if (!(self.window_fallback_emulation and self.setWarningFromBackendError(err))) {
                     return err;
                 }
@@ -624,6 +834,13 @@ pub const WindowState = struct {
 
     /// Applies a native window control command.
     pub fn control(self: *WindowState, cmd: WindowControl) !WindowControlResult {
+        self.state_mutex.lock();
+        defer self.state_mutex.unlock();
+        return self.controlLocked(cmd);
+    }
+
+    /// Applies a native window control command while holding `state_mutex`.
+    fn controlLocked(self: *WindowState, cmd: WindowControl) !WindowControlResult {
         self.emit(.window_state, "control", @tagName(cmd));
         self.clearWarning();
 
@@ -635,6 +852,10 @@ pub const WindowState = struct {
         if (self.isNativeWindowActive()) {
             const native_ok = blk: {
                 self.backend.control(cmd) catch |err| {
+                    if (err == error.NativeThreadAffinityViolation) {
+                        try self.dispatchNativeUiTaskLocked(.{ .control = cmd });
+                        break :blk true;
+                    }
                     if (self.window_fallback_emulation and self.setWarningFromBackendError(err)) {
                         break :blk false;
                     }
@@ -685,12 +906,87 @@ pub const WindowState = struct {
         };
     }
 
+    fn dispatchNativeUiTaskLocked(self: *WindowState, kind: NativeUiTask.Kind) !void {
+        const task = try NativeUiTask.init(self.allocator, kind);
+        errdefer task.deinit(self.allocator);
+        task.completion_owned_by_waiter = true;
+        try self.native_ui_pending.append(task);
+
+        self.state_mutex.unlock();
+
+        task.mutex.lock();
+        defer task.mutex.unlock();
+
+        const completed = waitForNativeUiTaskCompletion(task, native_ui_task_wait_timeout_ns, 250 * std.time.ns_per_ms);
+
+        self.state_mutex.lock();
+        _ = self.removePendingNativeUiTaskLocked(task);
+        defer task.deinit(self.allocator);
+
+        if (task.err) |err| return err;
+        if (!completed) return error.NativeThreadAffinityViolation;
+    }
+
+    /// Drains deferred native UI work on the owning platform thread while holding `state_mutex`.
+    pub fn dispatchPendingNativeUiTasksLocked(self: *WindowState) void {
+        while (self.native_ui_pending.items.len > 0) {
+            const task = self.native_ui_pending.orderedRemove(0);
+            var err: ?anyerror = null;
+            switch (task.kind) {
+                .apply_style => |style| {
+                    self.backend.applyStyle(style) catch |apply_err| {
+                        err = apply_err;
+                    };
+                },
+                .control => |cmd| {
+                    self.backend.control(cmd) catch |control_err| {
+                        err = control_err;
+                    };
+                },
+            }
+
+            task.mutex.lock();
+            task.err = err;
+            task.done = true;
+            task.cond.signal();
+            task.mutex.unlock();
+        }
+    }
+
+    fn removePendingNativeUiTaskLocked(self: *WindowState, task: *NativeUiTask) bool {
+        for (self.native_ui_pending.items, 0..) |pending, idx| {
+            if (pending == task) {
+                _ = self.native_ui_pending.orderedRemove(idx);
+                return true;
+            }
+        }
+        return false;
+    }
+
+    fn parseMessageIdU64(value: std.json.Value) ?u64 {
+        return switch (value) {
+            .integer => |v| if (v < 0) null else @as(u64, @intCast(v)),
+            .float => |v| blk: {
+                if (!std.math.isFinite(v) or v < 0) break :blk null;
+                if (@round(v) != v) break :blk null;
+                if (v > @as(f64, @floatFromInt(std.math.maxInt(u64)))) break :blk null;
+                break :blk @as(u64, @intFromFloat(v));
+            },
+            else => null,
+        };
+    }
+
     /// Emits a diagnostic event for this window.
     pub fn emitDiagnostic(
+        /// Stores the self.
         self: *WindowState,
+        /// Stores the code.
         code: []const u8,
+        /// Stores the category.
         category: DiagnosticCategory,
+        /// Stores the severity.
         severity: DiagnosticSeverity,
+        /// Stores the message.
         message: []const u8,
     ) void {
         const callback = self.diagnostic_callback.*;
@@ -701,7 +997,7 @@ pub const WindowState = struct {
                 .category = category,
                 .severity = severity,
                 .message = message,
-                .timestamp_ms = std.time.milliTimestamp(),
+                .timestamp_ms = time_compat.milliTimestamp(),
             };
             handler(callback.context, &diagnostic);
         }
@@ -888,6 +1184,113 @@ pub const WindowState = struct {
         }
     }
 
+    fn hasFrontendAttachmentLocked(self: *const WindowState) bool {
+        return self.ws_connections.items.len != 0;
+    }
+
+    /// Waits for a launched browser/frontend to attach to the local runtime.
+    pub fn waitForFrontendAttachment(self: *WindowState, allocator: std.mem.Allocator, timeout_ms: u32) bool {
+        const deadline = time_compat.milliTimestamp() + @as(i64, timeout_ms);
+
+        while (true) {
+            self.state_mutex.lock();
+            self.reconcileChildExit(allocator);
+            const attached = self.hasFrontendAttachmentLocked();
+            const close_requested = self.close_requested.load(.acquire);
+            self.state_mutex.unlock();
+
+            if (attached) return true;
+            if (close_requested) return false;
+            if (time_compat.milliTimestamp() >= deadline) return false;
+            time_compat.sleep(browser_attach_poll_ns);
+        }
+    }
+
+    /// Verifies that a launched browser/frontend attached after open.
+    pub fn verifyBrowserAttachedLocked(self: *WindowState, allocator: std.mem.Allocator) !void {
+        const timeout_ms = switch (self.runtime_render_state.active_surface) {
+            .browser_window => browser_attach_timeout_ms_browser_window,
+            .web_url => browser_attach_timeout_ms_web_url,
+            .native_webview => return,
+        };
+
+        self.state_mutex.unlock();
+        const attached = self.waitForFrontendAttachment(allocator, timeout_ms);
+        self.state_mutex.lock();
+
+        if (attached) return;
+        return error.BrowserFrontendAttachTimeout;
+    }
+
+    /// Retries attachment by reopening the current URL as a plain tab launch and waiting again.
+    pub fn retryUrlAttachFallbackLocked(self: *WindowState, allocator: std.mem.Allocator) bool {
+        const url = self.last_url orelse return false;
+        const launch = core_runtime.openInBrowser(allocator, url, self.current_style, .{
+            .surface_mode = .tab,
+            .fallback_mode = .allow_system,
+        }) catch return false;
+        self.setLaunchedBrowserLaunch(allocator, launch);
+        if (self.verifyBrowserAttachedLocked(allocator)) |_| {
+            return true;
+        } else |_| {
+            self.clearTrackedBrowserState(allocator);
+        }
+        return false;
+    }
+
+    fn launchBrowserSurfaceWithFallbackLockedWithOpener(
+        self: *WindowState,
+        allocator: std.mem.Allocator,
+        app_options: AppOptions,
+        verify_attach: bool,
+        opener: anytype,
+    ) !bool {
+        const url = self.last_url orelse return false;
+
+        while (true) {
+            const attempted_surface = self.runtime_render_state.active_surface;
+            const launch_options = self.effectiveBrowserLaunchOptions(app_options.browser_launch);
+
+            const launch = opener.open(allocator, url, self.current_style, launch_options) catch |err| {
+                const advanced = try self.advanceAfterBrowserLaunchFailureLocked(attempted_surface);
+                self.rpc_state.logf(.warn, "[webui.browser] launch failed error={s}\n", .{@errorName(err)});
+                if (!advanced) {
+                    if (attempted_surface == .browser_window and self.launch_policy.app_mode_required) return err;
+                    return false;
+                }
+                continue;
+            };
+
+            self.setLaunchedBrowserLaunch(allocator, launch);
+            if (!verify_attach) return true;
+
+            if (self.verifyBrowserAttachedLocked(allocator)) |_| {
+                return true;
+            } else |err| {
+                if (self.retryUrlAttachFallbackLocked(allocator)) return true;
+
+                self.clearTrackedBrowserState(allocator);
+                const advanced = try self.advanceAfterBrowserLaunchFailureLocked(self.runtime_render_state.active_surface);
+                self.rpc_state.logf(.warn, "[webui.browser] attach verification failed error={s}\n", .{@errorName(err)});
+                if (!advanced) {
+                    if (attempted_surface == .browser_window and self.launch_policy.app_mode_required) return err;
+                    return false;
+                }
+            }
+        }
+    }
+
+    /// Launches the active browser surface, retrying policy fallbacks until a launch succeeds or no surface remains.
+    pub fn launchBrowserSurfaceWithFallbackLocked(
+        self: *WindowState,
+        allocator: std.mem.Allocator,
+        app_options: AppOptions,
+        verify_attach: bool,
+    ) !bool {
+        var opener: RuntimeBrowserLauncher = .{};
+        return self.launchBrowserSurfaceWithFallbackLockedWithOpener(allocator, app_options, verify_attach, &opener);
+    }
+
     /// Starts the browser lifecycle close grace period after a frontend unload signal.
     pub fn requestLifecycleCloseFromFrontend(self: *WindowState) void {
         // Frontend lifecycle close is only used for browser-window mode.
@@ -949,25 +1352,26 @@ pub const WindowState = struct {
 
     /// Returns whether the current launch policy wants a browser surface.
     pub fn shouldOpenBrowser(self: *const WindowState) bool {
-        if (self.runtime_render_state.active_surface == .browser_window) return true;
-        if (self.runtime_render_state.active_surface == .native_webview) {
-            // Native launch may require host bootstrap on first render.
-            if (!self.backend.isReady()) return true;
-            if (!self.launch_policy.allow_dual_surface) return false;
-            return launchPolicyContains(self.launch_policy, .browser_window);
-        }
-        return false;
+        return switch (self.runtime_render_state.active_surface) {
+            .browser_window, .web_url => true,
+            .native_webview => self.launch_policy.allow_dual_surface and
+                (launchPolicyContains(self.launch_policy, .browser_window) or launchPolicyContains(self.launch_policy, .web_url)),
+        };
     }
 
     /// Returns whether browser spawning should be attempted while holding the window-state mutex.
     pub fn shouldAttemptBrowserSpawnLocked(
+        /// Stores the self.
         self: *WindowState,
+        /// Stores the allocator.
         allocator: std.mem.Allocator,
+        /// Stores the local render.
         local_render: bool,
     ) bool {
         if (!self.shouldOpenBrowser()) return false;
 
         if (local_render) {
+            if (self.frontend_connected) return false;
             if (self.launched_browser_pid) |pid| {
                 if (core_runtime.isProcessAlive(pid)) return false;
                 self.clearTrackedBrowserState(allocator);
@@ -991,16 +1395,23 @@ pub const WindowState = struct {
 
     /// Advances to the next launch surface after a browser launch failure while holding the window-state mutex.
     pub fn advanceAfterBrowserLaunchFailureLocked(
+        /// Stores the self.
         self: *WindowState,
+        /// Stores the failed surface.
         failed_surface: LaunchSurface,
     ) !bool {
         var last_failed = failed_surface;
         while (self.resolveAfterBrowserLaunchFailure(last_failed)) {
-            if (!self.nativeTransportSelected()) {
+            if (self.runtime_render_state.active_surface != .native_webview) {
                 self.native_capabilities = self.backend.capabilities();
                 return true;
             }
 
+            if (!self.backend.runtimeAvailable()) {
+                last_failed = .native_webview;
+                continue;
+            }
+
             self.backend.createWindow(self.id, self.title, self.current_style) catch |err| {
                 if (err == error.NativeBackendUnavailable) {
                     last_failed = .native_webview;
@@ -1033,18 +1444,132 @@ pub const WindowState = struct {
         // Prevent automated browser popups during `zig test`; tests can still
         // exercise HTTP/WS routes via the local URL and explicit APIs.
         if (builtin.is_test) return;
+        if (!self.startup_events_emitted) return;
 
         if (self.shouldAttemptBrowserSpawnLocked(allocator, true)) {
-            const launch_options = self.effectiveBrowserLaunchOptions(app_options.browser_launch);
-            if (core_runtime.openInBrowser(allocator, url, self.current_style, launch_options)) |launch| {
-                self.setLaunchedBrowserLaunch(allocator, launch);
-            } else |err| {
-                _ = try self.advanceAfterBrowserLaunchFailureLocked(self.runtime_render_state.active_surface);
-                self.rpc_state.logf(.warn, "[webui.browser] launch failed error={s}\n", .{@errorName(err)});
-                if (self.runtime_render_state.active_surface != .browser_window) return;
-                if (self.launch_policy.app_mode_required) return err;
+            try self.launchBrowserRenderLocked(allocator, app_options);
+        }
+    }
+
+    test "native ui task wait tolerates intermediate timed waits before completion" {
+        const Context = struct {
+            task: *NativeUiTask,
+
+            fn signal(ctx: *@This()) void {
+                time_compat.sleep(30 * std.time.ns_per_ms);
+                ctx.task.mutex.lock();
+                ctx.task.done = true;
+                ctx.task.cond.signal();
+                ctx.task.mutex.unlock();
             }
+        };
+
+        var task = NativeUiTask{ .kind = .{ .control = .show } };
+        var ctx = Context{ .task = &task };
+        const thread = try std.Thread.spawn(.{}, Context.signal, .{&ctx});
+        defer thread.join();
+
+        task.mutex.lock();
+        defer task.mutex.unlock();
+
+        try std.testing.expect(waitForNativeUiTaskCompletion(&task, 100 * std.time.ns_per_ms, 10 * std.time.ns_per_ms));
+    }
+
+    test "window state deinit frees non-awaited native ui tasks" {
+        var gpa = std.heap.DebugAllocator(.{}){};
+        defer {
+            const status = gpa.deinit();
+            if (status != .ok) std.debug.panic("window state deinit leaked pending native ui tasks", .{});
         }
+
+        var diagnostics: DiagnosticCallbackState = .{};
+        var state = try WindowState.init(gpa.allocator(), 1, .{ .title = "native-ui-pending-cleanup" }, .{}, &diagnostics);
+
+        const task = try NativeUiTask.init(gpa.allocator(), .{ .control = .show });
+        try state.native_ui_pending.append(task);
+
+        state.deinit(gpa.allocator());
+    }
+
+    test "local render does not respawn while frontend remains attached even without tracked browser metadata" {
+        var gpa = std.heap.DebugAllocator(.{}){};
+        defer _ = gpa.deinit();
+
+        var diagnostics: DiagnosticCallbackState = .{};
+        var state = try WindowState.init(gpa.allocator(), 1, .{ .title = "untracked-browser-guard" }, .{
+            .launch_policy = .{ .first = .web_url, .second = null, .third = null },
+        }, &diagnostics);
+        defer state.deinit(gpa.allocator());
+
+        state.frontend_connected = true;
+
+        state.state_mutex.lock();
+        const should_spawn = state.shouldAttemptBrowserSpawnLocked(gpa.allocator(), true);
+        state.state_mutex.unlock();
+
+        try std.testing.expect(!should_spawn);
+    }
+
+    test "browser launch fallback retries on the fallback surface" {
+        const FakeLauncher = struct {
+            calls: usize = 0,
+
+            fn open(
+                self: *@This(),
+                _: std.mem.Allocator,
+                _: []const u8,
+                _: WindowStyle,
+                launch_options: BrowserLaunchOptions,
+            ) !core_runtime.BrowserLaunch {
+                self.calls += 1;
+                return switch (self.calls) {
+                    1 => error.AppModeBrowserUnavailable,
+                    2 => .{
+                        .pid = null,
+                        .is_child_process = false,
+                        .lifecycle_linked = false,
+                        .kind = .firefox,
+                        .surface_mode = launch_options.surface_mode,
+                        .used_system_fallback = false,
+                    },
+                    else => unreachable,
+                };
+            }
+        };
+
+        var gpa = std.heap.DebugAllocator(.{}){};
+        defer _ = gpa.deinit();
+
+        var diagnostics: DiagnosticCallbackState = .{};
+        var state = try WindowState.init(gpa.allocator(), 1, .{ .title = "browser-launch-fallback-retry" }, .{
+            .launch_policy = .{
+                .first = .browser_window,
+                .second = .web_url,
+                .third = null,
+            },
+        }, &diagnostics);
+        defer state.deinit(gpa.allocator());
+
+        try replaceOwned(gpa.allocator(), &state.last_url, "http://127.0.0.1:4020/");
+
+        var launcher: FakeLauncher = .{};
+        state.state_mutex.lock();
+        defer state.state_mutex.unlock();
+
+        try std.testing.expect(try state.launchBrowserSurfaceWithFallbackLockedWithOpener(
+            gpa.allocator(),
+            .{},
+            false,
+            &launcher,
+        ));
+        try std.testing.expectEqual(@as(usize, 2), launcher.calls);
+        try std.testing.expectEqual(@as(LaunchSurface, .web_url), state.runtime_render_state.active_surface);
+        try std.testing.expectEqual(@as(?browser_discovery.BrowserKind, .firefox), state.launched_browser_kind);
+    }
+
+    /// Launches the browser render target immediately while holding the window-state mutex.
+    fn launchBrowserRenderLocked(self: *WindowState, allocator: std.mem.Allocator, app_options: AppOptions) !void {
+        _ = try self.launchBrowserSurfaceWithFallbackLocked(allocator, app_options, true);
     }
 
     const ClientRef = struct {
@@ -1054,7 +1579,7 @@ pub const WindowState = struct {
 
     /// Finds or creates a client session while holding the window-state mutex.
     pub fn findOrCreateClientSessionLocked(self: *WindowState, token: []const u8) !ClientRef {
-        const now_ms = std.time.milliTimestamp();
+        const now_ms = time_compat.milliTimestamp();
         for (self.client_sessions.items) |*session| {
             if (!std.mem.eql(u8, session.token, token)) continue;
             session.last_seen_ms = now_ms;
@@ -1085,10 +1610,15 @@ pub const WindowState = struct {
 
     /// Queues a script task while holding the window-state mutex.
     pub fn queueScriptLocked(
+        /// Stores the self.
         self: *WindowState,
+        /// Stores the allocator.
         allocator: std.mem.Allocator,
+        /// Stores the script.
         script: []const u8,
+        /// Stores the target connection.
         target_connection: ?usize,
+        /// Stores the expect result.
         expect_result: bool,
     ) !*ScriptTask {
         const task = try ScriptTask.init(allocator, self.next_script_id, script, target_connection, expect_result);
@@ -1100,11 +1630,17 @@ pub const WindowState = struct {
 
     /// Queues a frontend RPC task while holding the window-state mutex.
     pub fn queueFrontendRpcLocked(
+        /// Stores the self.
         self: *WindowState,
+        /// Stores the allocator.
         allocator: std.mem.Allocator,
+        /// Stores the function name.
         function_name: []const u8,
+        /// Stores the args json.
         args_json: []const u8,
+        /// Stores the target connection.
         target_connection: ?usize,
+        /// Stores the expect result.
         expect_result: bool,
     ) !*FrontendRpcTask {
         const task = try FrontendRpcTask.init(
@@ -1127,12 +1663,20 @@ pub const WindowState = struct {
     }
 
     /// Registers a websocket connection while holding the window-state mutex.
-    pub fn registerWsConnectionLocked(self: *WindowState, connection_id: usize, transport_value: anytype) !u64 {
+    pub const WsRegistration = struct {
+        /// Stores the generation.
+        generation: u64,
+        /// Stores the first connection.
+        first_connection: bool,
+    };
+
+    /// Registers or refreshes a websocket connection generation and dispatches any queued frontend work.
+    pub fn registerWsConnectionLocked(self: *WindowState, connection_id: usize, transport_value: anytype) !WsRegistration {
         // Reconnect during unload/refresh grace period means the page is back.
         // Cancel any pending lifecycle close request.
         self.cancelPendingLifecycleCloseLocked("websocket-connected");
         const transport: WsTransport = switch (@TypeOf(transport_value)) {
-            std.net.Stream => .{ .plain = transport_value },
+            std.Io.net.Stream => .{ .plain = transport_value },
             *https_server.Connection => .{ .tls = transport_value },
             else => @compileError("unsupported websocket transport type"),
         };
@@ -1147,16 +1691,26 @@ pub const WindowState = struct {
             entry.transport = transport;
             try self.dispatchPendingScriptTasksLocked();
             try self.dispatchPendingFrontendRpcTasksLocked();
-            return generation;
+            return .{
+                .generation = generation,
+                .first_connection = false,
+            };
         }
+        const first_connection = !self.frontend_connected and self.ws_connections.items.len == 0;
         try self.ws_connections.append(.{
             .connection_id = connection_id,
             .generation = generation,
             .transport = transport,
         });
+        if (first_connection) {
+            self.frontend_connected = true;
+        }
         try self.dispatchPendingScriptTasksLocked();
         try self.dispatchPendingFrontendRpcTasksLocked();
-        return generation;
+        return .{
+            .generation = generation,
+            .first_connection = first_connection,
+        };
     }
 
     /// Unregisters a websocket connection generation while holding the window-state mutex.
@@ -1165,6 +1719,9 @@ pub const WindowState = struct {
             if (entry.connection_id != connection_id) continue;
             if (entry.generation != generation) return false;
             _ = self.ws_connections.orderedRemove(idx);
+            if (self.ws_connections.items.len == 0) {
+                self.frontend_connected = false;
+            }
             return true;
         }
         return false;
@@ -1286,9 +1843,13 @@ pub const WindowState = struct {
     }
 
     fn buildFrontendRpcRequestPayload(
+        /// Stores the self.
         self: *WindowState,
+        /// Stores the task.
         task: *FrontendRpcTask,
+        /// Stores the connection id.
         connection_id: usize,
+        /// Stores the client id.
         client_id: usize,
     ) ![]u8 {
         const fn_name_json = try std.json.Stringify.valueAlloc(self.allocator, task.function_name, .{});
@@ -1296,21 +1857,20 @@ pub const WindowState = struct {
 
         var payload = std.array_list.Managed(u8).init(self.allocator);
         errdefer payload.deinit();
-        const writer = payload.writer();
-
-        try writer.writeAll("{\"type\":\"frontend_rpc_request\",\"id\":");
-        try writer.print("{d}", .{task.id});
-        try writer.writeAll(",\"name\":");
-        try writer.writeAll(fn_name_json);
-        try writer.writeAll(",\"args\":");
-        try writer.writeAll(task.args_json);
-        try writer.writeAll(",\"expect_result\":");
-        try writer.writeAll(if (task.expect_result) "true" else "false");
-        try writer.writeAll(",\"client_id\":");
-        try writer.print("{d}", .{client_id});
-        try writer.writeAll(",\"connection_id\":");
-        try writer.print("{d}", .{connection_id});
-        try writer.writeAll("}");
+
+        try payload.appendSlice("{\"type\":\"frontend_rpc_request\",\"id\":");
+        try payload.print("{d}", .{task.id});
+        try payload.appendSlice(",\"name\":");
+        try payload.appendSlice(fn_name_json);
+        try payload.appendSlice(",\"args\":");
+        try payload.appendSlice(task.args_json);
+        try payload.appendSlice(",\"expect_result\":");
+        try payload.appendSlice(if (task.expect_result) "true" else "false");
+        try payload.appendSlice(",\"client_id\":");
+        try payload.print("{d}", .{client_id});
+        try payload.appendSlice(",\"connection_id\":");
+        try payload.print("{d}", .{connection_id});
+        try payload.appendSlice("}");
 
         return payload.toOwnedSlice();
     }
@@ -1399,10 +1959,10 @@ pub const WindowState = struct {
     pub fn waitForCloseAckLocked(self: *WindowState, signal_id: u64, timeout_ms: u32) bool {
         if (signal_id == 0) return false;
         const timeout_ns: u64 = @as(u64, timeout_ms) * std.time.ns_per_ms;
-        const deadline = std.time.nanoTimestamp() + @as(i128, @intCast(timeout_ns));
+        const deadline = time_compat.nanoTimestamp() + @as(i128, @intCast(timeout_ns));
 
         while (self.last_close_ack_id < signal_id) {
-            const now = std.time.nanoTimestamp();
+            const now = time_compat.nanoTimestamp();
             if (now >= deadline) break;
             const remaining = @as(u64, @intCast(deadline - now));
             self.close_ack_cond.timedWait(&self.state_mutex, remaining) catch break;
@@ -1413,7 +1973,7 @@ pub const WindowState = struct {
     fn scheduleLifecycleCloseLocked(self: *WindowState) void {
         if (self.close_requested.load(.acquire)) return;
         self.lifecycle_close_pending = true;
-        self.lifecycle_close_deadline_ms = std.time.milliTimestamp() + lifecycle_close_grace_ms;
+        self.lifecycle_close_deadline_ms = time_compat.milliTimestamp() + lifecycle_close_grace_ms;
         self.rpc_state.logf(
             .debug,
             "[webui.lifecycle] scheduled browser-window close grace_ms={d}\n",
@@ -1442,7 +2002,7 @@ pub const WindowState = struct {
             self.cancelPendingLifecycleCloseLocked("websocket-reconnected");
             return;
         }
-        if (std.time.milliTimestamp() < self.lifecycle_close_deadline_ms) return;
+        if (time_compat.milliTimestamp() < self.lifecycle_close_deadline_ms) return;
 
         self.lifecycle_close_pending = false;
         self.lifecycle_close_deadline_ms = 0;
@@ -1485,10 +2045,15 @@ pub const WindowState = struct {
 
     /// Completes a script task with its result while holding the window-state mutex.
     pub fn completeScriptTaskLocked(
+        /// Stores the self.
         self: *WindowState,
+        /// Stores the task id.
         task_id: u64,
+        /// Stores the js error.
         js_error: bool,
+        /// Stores the value json.
         value_json: ?[]const u8,
+        /// Stores the error message.
         error_message: ?[]const u8,
     ) !bool {
         for (self.script_inflight.items, 0..) |task, idx| {
@@ -1555,10 +2120,15 @@ pub const WindowState = struct {
 
     /// Completes a frontend RPC task with its result while holding the window-state mutex.
     pub fn completeFrontendRpcTaskLocked(
+        /// Stores the self.
         self: *WindowState,
+        /// Stores the task id.
         task_id: u64,
+        /// Stores the js error.
         js_error: bool,
+        /// Stores the value json.
         value_json: ?[]const u8,
+        /// Stores the error message.
         error_message: ?[]const u8,
     ) !bool {
         for (self.frontend_rpc_inflight.items, 0..) |task, idx| {
@@ -1614,11 +2184,7 @@ pub const WindowState = struct {
 
         if (std.mem.eql(u8, msg_type_value.string, "close_ack")) {
             const id_value = parsed.value.object.get("id") orelse return;
-            const ack_id: u64 = switch (id_value) {
-                .integer => |v| @as(u64, @intCast(v)),
-                .float => |v| @as(u64, @intFromFloat(v)),
-                else => return,
-            };
+            const ack_id = parseMessageIdU64(id_value) orelse return;
 
             self.state_mutex.lock();
             if (ack_id > self.last_close_ack_id) {
@@ -1642,11 +2208,7 @@ pub const WindowState = struct {
 
         if (std.mem.eql(u8, msg_type_value.string, "frontend_rpc_response")) {
             const id_value = parsed.value.object.get("id") orelse return;
-            const task_id: u64 = switch (id_value) {
-                .integer => |v| @as(u64, @intCast(v)),
-                .float => |v| @as(u64, @intFromFloat(v)),
-                else => return,
-            };
+            const task_id = parseMessageIdU64(id_value) orelse return;
 
             const js_error = if (parsed.value.object.get("js_error")) |err_val|
                 switch (err_val) {
@@ -1679,11 +2241,7 @@ pub const WindowState = struct {
         if (!std.mem.eql(u8, msg_type_value.string, "script_response")) return;
 
         const id_value = parsed.value.object.get("id") orelse return;
-        const task_id: u64 = switch (id_value) {
-            .integer => |v| @as(u64, @intCast(v)),
-            .float => |v| @as(u64, @intFromFloat(v)),
-            else => return,
-        };
+        const task_id = parseMessageIdU64(id_value) orelse return;
 
         const js_error = if (parsed.value.object.get("js_error")) |err_val|
             switch (err_val) {
@@ -1752,6 +2310,18 @@ pub const WindowState = struct {
             task.deinit();
         }
         self.frontend_rpc_inflight.deinit();
+
+        for (self.native_ui_pending.items) |task| {
+            task.mutex.lock();
+            task.err = error.NativeWindowClosed;
+            task.done = true;
+            task.cond.broadcast();
+            task.mutex.unlock();
+            if (!task.completion_owned_by_waiter) {
+                task.deinit(self.allocator);
+            }
+        }
+        self.native_ui_pending.deinit();
         self.ws_connections.deinit();
 
         self.terminateLaunchedBrowser(allocator);
@@ -1788,15 +2358,15 @@ pub const WindowState = struct {
 
     /// Waits until the local HTTP server is accepting connections.
     pub fn ensureServerReachable(self: *WindowState) !void {
-        const address = try std.net.Address.parseIp4("127.0.0.1", self.server_port);
+        const address = try std.Io.net.IpAddress.parseIp4("127.0.0.1", self.server_port);
 
         var attempt: usize = 0;
         while (attempt < 25) : (attempt += 1) {
-            const stream = std.net.tcpConnectToAddress(address) catch {
-                std.Thread.sleep(20 * std.time.ns_per_ms);
+            const stream = std.Io.net.IpAddress.connect(&address, io_compat.io, .{ .mode = .stream }) catch {
+                time_compat.sleep(20 * std.time.ns_per_ms);
                 continue;
             };
-            stream.close();
+            stream.close(io_compat.io);
             return;
         }
 
@@ -1808,6 +2378,15 @@ pub const WindowState = struct {
         self.server_stop.store(true, .release);
         self.server_ready_cond.broadcast();
 
+        // Wake a blocking accept() so the server thread can observe server_stop.
+        const wake_addr = std.Io.net.IpAddress.parseIp4("127.0.0.1", self.server_port) catch null;
+        if (wake_addr) |addr| {
+            const wake_stream = std.Io.net.IpAddress.connect(&addr, io_compat.io, .{ .mode = .stream }) catch null;
+            if (wake_stream) |stream| {
+                stream.close(io_compat.io);
+            }
+        }
+
         if (self.server_thread) |thread| {
             thread.join();
             self.server_thread = null;
@@ -1827,7 +2406,7 @@ pub const WindowState = struct {
     /// Runs the per-window HTTP server accept loop.
     pub fn serverThreadMain(self: *WindowState) void {
         const bind_host = if (self.server_bind_public) "0.0.0.0" else "127.0.0.1";
-        const address = std.net.Address.parseIp4(bind_host, self.server_port) catch {
+        const address = std.Io.net.IpAddress.parseIp4(bind_host, self.server_port) catch {
             self.server_ready_mutex.lock();
             self.server_listen_ok = false;
             self.server_ready = true;
@@ -1836,7 +2415,7 @@ pub const WindowState = struct {
             return;
         };
 
-        var server = address.listen(.{ .reuse_address = true, .force_nonblocking = true }) catch {
+        var server = std.Io.net.IpAddress.listen(&address, io_compat.io, .{ .reuse_address = true }) catch {
             self.server_ready_mutex.lock();
             self.server_listen_ok = false;
             self.server_ready = true;
@@ -1844,36 +2423,41 @@ pub const WindowState = struct {
             self.server_ready_mutex.unlock();
             return;
         };
-        defer server.deinit();
+        defer server.deinit(io_compat.io);
 
         self.server_ready_mutex.lock();
-        self.server_port = server.listen_address.getPort();
+        self.server_port = server.socket.address.getPort();
         self.server_listen_ok = true;
         self.server_ready = true;
         self.server_ready_cond.broadcast();
         self.server_ready_mutex.unlock();
 
         while (!self.server_stop.load(.acquire)) {
-            const conn = server.accept() catch |err| {
+            const stream = server.accept(io_compat.io) catch |err| {
                 switch (err) {
                     error.WouldBlock => {
-                        std.Thread.sleep(5 * std.time.ns_per_ms);
+                        time_compat.sleep(5 * std.time.ns_per_ms);
                         continue;
                     },
                     else => continue,
                 }
             };
 
+            if (self.server_stop.load(.acquire)) {
+                stream.close(io_compat.io);
+                break;
+            }
+
             self.connection_mutex.lock();
             self.active_connection_workers += 1;
             self.connection_mutex.unlock();
 
-            const thread = std.Thread.spawn(.{}, connectionThreadMain, .{ self, conn.stream }) catch {
+            const thread = std.Thread.spawn(.{}, connectionThreadMain, .{ self, stream }) catch {
                 self.connection_mutex.lock();
                 self.active_connection_workers -= 1;
                 self.connection_cond.broadcast();
                 self.connection_mutex.unlock();
-                conn.stream.close();
+                stream.close(io_compat.io);
                 continue;
             };
             thread.detach();
@@ -1881,7 +2465,7 @@ pub const WindowState = struct {
     }
 
     /// Handles one accepted HTTP or TLS connection.
-    pub fn connectionThreadMain(self: *WindowState, stream: std.net.Stream) void {
+    pub fn connectionThreadMain(self: *WindowState, stream: std.Io.net.Stream) void {
         defer {
             self.connection_mutex.lock();
             if (self.active_connection_workers > 0) {
@@ -1896,47 +2480,47 @@ pub const WindowState = struct {
             if (first_byte) |byte| {
                 if (!https_server.looksLikeTlsClientHello(byte)) {
                     const request = net_io.readHttpRequest(std.heap.page_allocator, stream) catch {
-                        stream.close();
+                        stream.close(io_compat.io);
                         return;
                     };
                     defer std.heap.page_allocator.free(request.raw);
 
                     const fallback_host = std.fmt.allocPrint(std.heap.page_allocator, "127.0.0.1:{d}", .{self.server_port}) catch {
-                        stream.close();
+                        stream.close(io_compat.io);
                         return;
                     };
                     defer std.heap.page_allocator.free(fallback_host);
                     const host = net_io.httpHeaderValue(request.headers, "Host") orelse fallback_host;
 
-                    const redirect_url = std.fmt.allocPrint(std.heap.page_allocator, "https://{s}{s}", .{ host, request.path }) catch {
-                        stream.close();
+                    const redirect_url = std.fmt.allocPrint(std.heap.page_allocator, "https://{s}{s}", .{ host, request.target }) catch {
+                        stream.close(io_compat.io);
                         return;
                     };
                     defer std.heap.page_allocator.free(redirect_url);
 
                     net_io.writeHttpRedirectAny(stream, redirect_url) catch {};
-                    stream.close();
+                    stream.close(io_compat.io);
                     return;
                 }
             }
 
             const cert_pem = self.server_tls_cert_pem orelse {
-                stream.close();
+                stream.close(io_compat.io);
                 return;
             };
             const key_pem = self.server_tls_key_pem orelse {
-                stream.close();
+                stream.close(io_compat.io);
                 return;
             };
 
             const tls_conn = std.heap.page_allocator.create(https_server.Connection) catch {
-                stream.close();
+                stream.close(io_compat.io);
                 return;
             };
             tls_conn.* = https_server.Connection.initServer(std.heap.page_allocator, stream, cert_pem, key_pem) catch |err| {
                 self.emitDiagnostic("tls.handshake.error", .tls, .warn, @errorName(err));
                 std.heap.page_allocator.destroy(tls_conn);
-                stream.close();
+                stream.close(io_compat.io);
                 return;
             };
 
@@ -1953,11 +2537,11 @@ pub const WindowState = struct {
         }
 
         const transfer_plain_ownership = server_routes.handleConnection(self, std.heap.page_allocator, stream, default_client_token) catch {
-            stream.close();
+            stream.close(io_compat.io);
             return;
         };
         if (!transfer_plain_ownership) {
-            stream.close();
+            stream.close(io_compat.io);
         }
     }
 };
diff --git a/src/root/window_style.zig b/src/root/window_style.zig
index 793b110..bff041d 100644
--- a/src/root/window_style.zig
+++ b/src/root/window_style.zig
@@ -1,51 +1,88 @@
 const std = @import("std");
 
+/// Stores size.
 pub const Size = struct {
+    /// Stores the width.
     width: u32,
+    /// Stores the height.
     height: u32,
 };
 
+/// Stores point.
 pub const Point = struct {
+    /// Stores the x.
     x: i32,
+    /// Stores the y.
     y: i32,
 };
 
+/// Stores window icon.
 pub const WindowIcon = struct {
+    /// Stores the bytes.
     bytes: []const u8,
+    /// Stores the mime type.
     mime_type: []const u8,
 };
 
+/// Stores window style.
 pub const WindowStyle = struct {
+    /// Stores the frameless.
     frameless: bool = false,
+    /// Stores the transparent.
     transparent: bool = false,
+    /// Stores the corner radius.
     corner_radius: ?u16 = null,
+    /// Stores the resizable.
     resizable: bool = true,
+    /// Stores the kiosk.
     kiosk: bool = false,
+    /// Stores the hidden.
     hidden: bool = false,
+    /// Stores the size.
     size: ?Size = null,
+    /// Stores the min size.
     min_size: ?Size = null,
+    /// Stores the position.
     position: ?Point = null,
+    /// Stores the center.
     center: bool = false,
+    /// Stores the icon.
     icon: ?WindowIcon = null,
+    /// Stores the high contrast.
     high_contrast: ?bool = null,
 };
 
+/// Enumerates window control values.
 pub const WindowControl = enum {
+    /// Selects `minimize`.
     minimize,
+    /// Selects `maximize`.
     maximize,
+    /// Selects `restore`.
     restore,
+    /// Selects `close`.
     close,
+    /// Selects `hide`.
     hide,
+    /// Selects `show`.
     show,
 };
 
+/// Enumerates window capability values.
 pub const WindowCapability = enum {
+    /// Selects `native_frameless`.
     native_frameless,
+    /// Selects `native_transparency`.
     native_transparency,
+    /// Selects `native_corner_radius`.
     native_corner_radius,
+    /// Selects `native_positioning`.
     native_positioning,
+    /// Selects `native_minmax`.
     native_minmax,
+    /// Selects `native_icon`.
     native_icon,
+    /// Selects `native_kiosk`.
     native_kiosk,
 };
 
diff --git a/src/thread_compat.zig b/src/thread_compat.zig
new file mode 100644
index 0000000..e87733e
--- /dev/null
+++ b/src/thread_compat.zig
@@ -0,0 +1,87 @@
+const std = @import("std");
+
+fn monotonicNowNs() i128 {
+    var threaded: std.Io.Threaded = .init(std.heap.smp_allocator, .{});
+    defer threaded.deinit();
+    const io = threaded.io();
+    return @as(i128, @intCast(std.Io.Timestamp.now(io, .awake).nanoseconds));
+}
+
+/// Stores mutex.
+pub const Mutex = struct {
+    /// Stores the inner.
+    inner: std.Io.Mutex = .init,
+
+    pub const init: Mutex = .{};
+
+    /// Attempts to acquire the mutex without blocking.
+    pub fn tryLock(self: *Mutex) bool {
+        return self.inner.tryLock();
+    }
+
+    /// Acquires the mutex and blocks until ownership is granted.
+    pub fn lock(self: *Mutex) void {
+        var threaded: std.Io.Threaded = .init(std.heap.smp_allocator, .{});
+        defer threaded.deinit();
+        self.inner.lockUncancelable(threaded.io());
+    }
+
+    /// Releases the mutex currently held by the caller.
+    pub fn unlock(self: *Mutex) void {
+        var threaded: std.Io.Threaded = .init(std.heap.smp_allocator, .{});
+        defer threaded.deinit();
+        self.inner.unlock(threaded.io());
+    }
+};
+
+/// Stores condition.
+pub const Condition = struct {
+    /// Stores the inner.
+    inner: std.Io.Condition = .init,
+    /// Stores the epoch.
+    epoch: std.atomic.Value(u64) = .init(0),
+
+    pub const init: Condition = .{};
+
+    /// Waits until another thread signals the condition while temporarily releasing `mutex`.
+    pub fn wait(self: *Condition, mutex: *Mutex) void {
+        var threaded: std.Io.Threaded = .init(std.heap.smp_allocator, .{});
+        defer threaded.deinit();
+        self.inner.waitUncancelable(threaded.io(), &mutex.inner);
+    }
+
+    /// Waits for a signal until `timeout_ns` elapses, returning `error.Timeout` on deadline expiry.
+    pub fn timedWait(self: *Condition, mutex: *Mutex, timeout_ns: u64) error{Timeout}!void {
+        const start_epoch = self.epoch.load(.acquire);
+        const deadline_ns = monotonicNowNs() + @as(i128, @intCast(timeout_ns));
+        while (self.epoch.load(.acquire) == start_epoch) {
+            const now_ns = monotonicNowNs();
+            if (now_ns >= deadline_ns) return error.Timeout;
+
+            mutex.unlock();
+            defer mutex.lock();
+
+            const remaining_ns: u64 = @intCast(deadline_ns - now_ns);
+            const sleep_ns = @min(remaining_ns, std.time.ns_per_ms);
+            var threaded: std.Io.Threaded = .init(std.heap.smp_allocator, .{});
+            defer threaded.deinit();
+            std.Io.sleep(threaded.io(), std.Io.Duration.fromNanoseconds(@intCast(sleep_ns)), .awake) catch {};
+        }
+    }
+
+    /// Wakes one waiter blocked on this condition.
+    pub fn signal(self: *Condition) void {
+        _ = self.epoch.fetchAdd(1, .acq_rel);
+        var threaded: std.Io.Threaded = .init(std.heap.smp_allocator, .{});
+        defer threaded.deinit();
+        self.inner.signal(threaded.io());
+    }
+
+    /// Wakes every waiter currently blocked on this condition.
+    pub fn broadcast(self: *Condition) void {
+        _ = self.epoch.fetchAdd(1, .acq_rel);
+        var threaded: std.Io.Threaded = .init(std.heap.smp_allocator, .{});
+        defer threaded.deinit();
+        self.inner.broadcast(threaded.io());
+    }
+};
diff --git a/src/time_compat.zig b/src/time_compat.zig
new file mode 100644
index 0000000..ef8fdc0
--- /dev/null
+++ b/src/time_compat.zig
@@ -0,0 +1,21 @@
+const std = @import("std");
+
+/// Returns a monotonic nanosecond timestamp.
+pub fn nanoTimestamp() i128 {
+    var threaded: std.Io.Threaded = .init(std.heap.smp_allocator, .{});
+    defer threaded.deinit();
+    const io = threaded.io();
+    return @as(i128, @intCast(std.Io.Timestamp.now(io, .awake).nanoseconds));
+}
+
+/// Returns a monotonic millisecond timestamp.
+pub fn milliTimestamp() i64 {
+    return @as(i64, @intCast(@divTrunc(nanoTimestamp(), std.time.ns_per_ms)));
+}
+
+/// Sleeps for `ns` nanoseconds.
+pub fn sleep(ns: u64) void {
+    var threaded: std.Io.Threaded = .init(std.heap.smp_allocator, .{});
+    defer threaded.deinit();
+    std.Io.sleep(threaded.io(), std.Io.Duration.fromNanoseconds(@intCast(ns)), .awake) catch {};
+}
diff --git a/tools/bridge_gen.zig b/tools/bridge_gen.zig
index 2d8a045..2b7fc48 100644
--- a/tools/bridge_gen.zig
+++ b/tools/bridge_gen.zig
@@ -1,23 +1,24 @@
 const std = @import("std");
 const template = @import("bridge_template");
 
-pub fn main() !void {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
-    defer _ = gpa.deinit();
-    const allocator = gpa.allocator();
-
-    const args = try std.process.argsAlloc(allocator);
-    defer std.process.argsFree(allocator, args);
-
-    if (args.len < 2) {
+pub fn main(init: std.process.Init) !void {
+    const allocator = init.gpa;
+    const cwd = std.Io.Dir.cwd();
+
+    var args_iter = try init.minimal.args.iterateAllocator(allocator);
+    defer args_iter.deinit();
+    _ = args_iter.next(); // exe name
+    const output_js_path = args_iter.next() orelse {
+        std.debug.print("usage: bridge_gen <output-js-path> [comma-separated-functions] [output-dts-path]\n", .{});
+        return error.InvalidArguments;
+    };
+    const function_csv: []const u8 = args_iter.next() orelse "ping";
+    const output_dts_path: ?[]const u8 = args_iter.next();
+    if (args_iter.next() != null) {
         std.debug.print("usage: bridge_gen <output-js-path> [comma-separated-functions] [output-dts-path]\n", .{});
         return error.InvalidArguments;
     }
 
-    const output_js_path = args[1];
-    const function_csv: []const u8 = if (args.len >= 3) args[2] else "ping";
-    const output_dts_path: ?[]const u8 = if (args.len >= 4) args[3] else null;
-
     var metas = std.array_list.Managed(template.RpcFunctionMeta).init(allocator);
     defer metas.deinit();
 
@@ -32,23 +33,27 @@ pub fn main() !void {
     defer allocator.free(script_js);
 
     if (std.fs.path.dirname(output_js_path)) |dir_name| {
-        try std.fs.cwd().makePath(dir_name);
+        try cwd.createDirPath(init.io, dir_name);
     }
 
-    const file = try std.fs.cwd().createFile(output_js_path, .{ .truncate = true });
-    defer file.close();
-    try file.writeAll(script_js);
+    try cwd.writeFile(init.io, .{
+        .sub_path = output_js_path,
+        .data = script_js,
+        .flags = .{ .truncate = true },
+    });
 
     if (output_dts_path) |dts_path| {
         const script_dts = try template.renderTypeScriptDeclarations(allocator, .{}, metas.items);
         defer allocator.free(script_dts);
 
         if (std.fs.path.dirname(dts_path)) |dir_name| {
-            try std.fs.cwd().makePath(dir_name);
+            try cwd.createDirPath(init.io, dir_name);
         }
 
-        const dts_file = try std.fs.cwd().createFile(dts_path, .{ .truncate = true });
-        defer dts_file.close();
-        try dts_file.writeAll(script_dts);
+        try cwd.writeFile(init.io, .{
+            .sub_path = dts_path,
+            .data = script_dts,
+            .flags = .{ .truncate = true },
+        });
     }
 }
diff --git a/tools/js_asset_gen.zig b/tools/js_asset_gen.zig
index 0cf41ee..dde4da7 100644
--- a/tools/js_asset_gen.zig
+++ b/tools/js_asset_gen.zig
@@ -1,46 +1,55 @@
 const std = @import("std");
 
-pub fn main() !void {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
-    defer _ = gpa.deinit();
-    const allocator = gpa.allocator();
+pub fn main(init: std.process.Init) !void {
+    const allocator = init.gpa;
+    const cwd = std.Io.Dir.cwd();
 
-    const args = try std.process.argsAlloc(allocator);
-    defer std.process.argsFree(allocator, args);
-
-    if (args.len != 4) {
+    var args_iter = try init.minimal.args.iterateAllocator(allocator);
+    defer args_iter.deinit();
+    _ = args_iter.next(); // exe name
+    const input_path = args_iter.next() orelse {
+        std.debug.print("usage: js_asset_gen <input-js> <output-js> <minify:0|1>\n", .{});
+        return error.InvalidArguments;
+    };
+    const output_path = args_iter.next() orelse {
+        std.debug.print("usage: js_asset_gen <input-js> <output-js> <minify:0|1>\n", .{});
+        return error.InvalidArguments;
+    };
+    const minify_arg = args_iter.next() orelse {
+        std.debug.print("usage: js_asset_gen <input-js> <output-js> <minify:0|1>\n", .{});
+        return error.InvalidArguments;
+    };
+    if (args_iter.next() != null) {
         std.debug.print("usage: js_asset_gen <input-js> <output-js> <minify:0|1>\n", .{});
         return error.InvalidArguments;
     }
 
-    const input_path = args[1];
-    const output_path = args[2];
-    const minify = std.mem.eql(u8, args[3], "1");
+    const minify = std.mem.eql(u8, minify_arg, "1");
 
     if (std.fs.path.dirname(output_path)) |dir_name| {
-        try std.fs.cwd().makePath(dir_name);
+        try cwd.createDirPath(init.io, dir_name);
     }
 
-    try copyFile(input_path, output_path, minify);
+    try copyFile(allocator, init.io, input_path, output_path, minify);
 }
 
-fn copyFile(input_path: []const u8, output_path: []const u8, minify: bool) !void {
-    const input = try std.fs.cwd().openFile(input_path, .{});
-    defer input.close();
-
-    const data = try input.readToEndAlloc(std.heap.page_allocator, 4 * 1024 * 1024);
-    defer std.heap.page_allocator.free(data);
+fn copyFile(allocator: std.mem.Allocator, io: std.Io, input_path: []const u8, output_path: []const u8, minify: bool) !void {
+    const cwd = std.Io.Dir.cwd();
+    const data = try cwd.readFileAlloc(io, input_path, allocator, .limited(4 * 1024 * 1024));
+    defer allocator.free(data);
 
-    const output = try std.fs.cwd().createFile(output_path, .{ .truncate = true });
-    defer output.close();
     if (!minify) {
-        try output.writeAll(data);
+        try cwd.writeFile(io, .{
+            .sub_path = output_path,
+            .data = data,
+            .flags = .{ .truncate = true },
+        });
         return;
     }
 
     // Pure Zig build: no external jsmin binary and no C compilation dependency.
     // Keep deterministic output by trimming trailing spaces and normalizing line-endings.
-    var out = std.array_list.Managed(u8).init(std.heap.page_allocator);
+    var out = std.array_list.Managed(u8).init(allocator);
     defer out.deinit();
 
     var it = std.mem.splitScalar(u8, data, '\n');
@@ -49,10 +58,14 @@ fn copyFile(input_path: []const u8, output_path: []const u8, minify: bool) !void
         if (line.len > 0 and line[line.len - 1] == '\r') {
             line = line[0 .. line.len - 1];
         }
-        line = std.mem.trimRight(u8, line, " \t");
+        line = std.mem.trimEnd(u8, line, " \t");
         try out.appendSlice(line);
         try out.append('\n');
     }
 
-    try output.writeAll(out.items);
+    try cwd.writeFile(io, .{
+        .sub_path = output_path,
+        .data = out.items,
+        .flags = .{ .truncate = true },
+    });
 }
diff --git a/tools/parity_report.zig b/tools/parity_report.zig
index 2325a7a..b985a97 100644
--- a/tools/parity_report.zig
+++ b/tools/parity_report.zig
@@ -11,23 +11,28 @@ const StatusEntry = struct {
     status: []const u8,
 };
 
-pub fn main() !void {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
-    defer _ = gpa.deinit();
-    const allocator = gpa.allocator();
-
-    const args = try std.process.argsAlloc(allocator);
-    defer std.process.argsFree(allocator, args);
-
-    if (args.len != 3) {
+pub fn main(init: std.process.Init) !void {
+    const allocator = init.gpa;
+    var args_iter = try init.minimal.args.iterateAllocator(allocator);
+    defer args_iter.deinit();
+    _ = args_iter.next(); // exe name
+    const features_path = args_iter.next() orelse {
+        std.debug.print("usage: parity_report <features.json> <status.json>\n", .{});
+        return error.InvalidArguments;
+    };
+    const status_path = args_iter.next() orelse {
+        std.debug.print("usage: parity_report <features.json> <status.json>\n", .{});
+        return error.InvalidArguments;
+    };
+    if (args_iter.next() != null) {
         std.debug.print("usage: parity_report <features.json> <status.json>\n", .{});
         return error.InvalidArguments;
     }
 
-    const feature_entries = try loadFeatures(allocator, args[1]);
+    const feature_entries = try loadFeatures(allocator, init.io, features_path);
     defer freeFeatures(allocator, feature_entries);
 
-    const status_entries = try loadStatus(allocator, args[2]);
+    const status_entries = try loadStatus(allocator, init.io, status_path);
     defer freeStatus(allocator, status_entries);
 
     var feature_set = std.StringHashMap(void).init(allocator);
@@ -106,8 +111,8 @@ fn isValidStatus(status: []const u8) bool {
         std.mem.eql(u8, status, "missing");
 }
 
-fn loadFeatures(allocator: std.mem.Allocator, path: []const u8) ![]Feature {
-    const bytes = try readFile(allocator, path);
+fn loadFeatures(allocator: std.mem.Allocator, io: std.Io, path: []const u8) ![]Feature {
+    const bytes = try readFile(allocator, io, path);
     defer allocator.free(bytes);
 
     var parsed = try std.json.parseFromSlice(std.json.Value, allocator, bytes, .{});
@@ -143,8 +148,8 @@ fn freeFeatures(allocator: std.mem.Allocator, entries: []Feature) void {
     allocator.free(entries);
 }
 
-fn loadStatus(allocator: std.mem.Allocator, path: []const u8) ![]StatusEntry {
-    const bytes = try readFile(allocator, path);
+fn loadStatus(allocator: std.mem.Allocator, io: std.Io, path: []const u8) ![]StatusEntry {
+    const bytes = try readFile(allocator, io, path);
     defer allocator.free(bytes);
 
     var parsed = try std.json.parseFromSlice(std.json.Value, allocator, bytes, .{});
@@ -177,8 +182,6 @@ fn freeStatus(allocator: std.mem.Allocator, entries: []StatusEntry) void {
     allocator.free(entries);
 }
 
-fn readFile(allocator: std.mem.Allocator, path: []const u8) ![]u8 {
-    const file = try std.fs.cwd().openFile(path, .{});
-    defer file.close();
-    return try file.readToEndAlloc(allocator, 16 * 1024 * 1024);
+fn readFile(allocator: std.mem.Allocator, io: std.Io, path: []const u8) ![]u8 {
+    return std.Io.Dir.cwd().readFileAlloc(io, path, allocator, .limited(16 * 1024 * 1024));
 }
diff --git a/tools/vfs_gen.zig b/tools/vfs_gen.zig
index d1a081f..0d3e69e 100644
--- a/tools/vfs_gen.zig
+++ b/tools/vfs_gen.zig
@@ -1,42 +1,46 @@
 const std = @import("std");
 
-pub fn main() !void {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
-    defer _ = gpa.deinit();
-    const allocator = gpa.allocator();
-
-    const args = try std.process.argsAlloc(allocator);
-    defer std.process.argsFree(allocator, args);
-
-    if (args.len != 3) {
+pub fn main(init: std.process.Init) !void {
+    const allocator = init.gpa;
+    const cwd = std.Io.Dir.cwd();
+
+    var args_iter = try init.minimal.args.iterateAllocator(allocator);
+    defer args_iter.deinit();
+    _ = args_iter.next(); // exe name
+    const input_path = args_iter.next() orelse {
+        std.debug.print("usage: vfs_gen <input-file> <output-zig>\n", .{});
+        return error.InvalidArguments;
+    };
+    const output_path = args_iter.next() orelse {
+        std.debug.print("usage: vfs_gen <input-file> <output-zig>\n", .{});
+        return error.InvalidArguments;
+    };
+    if (args_iter.next() != null) {
         std.debug.print("usage: vfs_gen <input-file> <output-zig>\n", .{});
         return error.InvalidArguments;
     }
 
-    const input_path = args[1];
-    const output_path = args[2];
-
-    const content = try std.fs.cwd().readFileAlloc(allocator, input_path, 16 * 1024 * 1024);
+    const content = try cwd.readFileAlloc(init.io, input_path, allocator, .limited(16 * 1024 * 1024));
     defer allocator.free(content);
 
     if (std.fs.path.dirname(output_path)) |dir_name| {
-        try std.fs.cwd().makePath(dir_name);
+        try cwd.createDirPath(init.io, dir_name);
     }
 
-    const out = try std.fs.cwd().createFile(output_path, .{ .truncate = true });
-    defer out.close();
+    var out = try cwd.createFile(init.io, output_path, .{ .truncate = true });
+    defer out.close(init.io);
 
-    try out.writeAll("pub const bytes = [_]u8{\n");
+    try out.writeStreamingAll(init.io, "pub const bytes = [_]u8{\n");
     for (content, 0..) |byte, idx| {
-        if (idx % 16 == 0) try out.writeAll("    ");
+        if (idx % 16 == 0) try out.writeStreamingAll(init.io, "    ");
 
         var num_buf: [16]u8 = undefined;
         const num = try std.fmt.bufPrint(&num_buf, "0x{x:0>2}", .{byte});
-        try out.writeAll(num);
+        try out.writeStreamingAll(init.io, num);
 
-        if (idx + 1 != content.len) try out.writeAll(", ");
-        if (idx % 16 == 15) try out.writeAll("\n");
+        if (idx + 1 != content.len) try out.writeStreamingAll(init.io, ", ");
+        if (idx % 16 == 15) try out.writeStreamingAll(init.io, "\n");
     }
-    if (content.len % 16 != 0) try out.writeAll("\n");
-    try out.writeAll("};\n");
+    if (content.len % 16 != 0) try out.writeStreamingAll(init.io, "\n");
+    try out.writeStreamingAll(init.io, "};\n");
 }