Add simulator audio support

- Run SDL from main() and place FreeRTOS in separate thread. This fixes macOS support.
- Updated GitHub Actions to publish macOS simulator build for testing, updated amd64 to x86_64 for consistent naming.

.claude/rules/CLAUDE.md

@@ -63,3 +63,7 @@ Strong success criteria let you loop independently. Weak criteria ("make it work
 ---
 
 **These guidelines are working if:** fewer unnecessary changes in diffs, fewer rewrites due to overcomplication, and clarifying questions come before implementation rather than after mistakes.
+
+For current-firmware merges, board customization retention, ESP-IDF build/flash,
+and external-app compatibility verification, also follow
+`.claude/skills/tactility-firmware-development/SKILL.md`.

.claude/skills/tactility-firmware-development/SKILL.md

@@ -0,0 +1,208 @@
+---
+name: tactility-firmware-development
+description: Use when merging current Tactility firmware, preserving local ES3C28P/ES3C35P customizations, building/flashing ESP32 firmware, or validating external apps against it.
+---
+
+# Tactility firmware development
+
+## Scope and success criteria
+
+Use this skill for firmware upgrades, especially when upstream changes the app
+loader, dashboard API, SDK export, or device model. Before editing, record the
+active branch, `git status --short`, selected `Devices/<id>`, serial port, and
+the expected device identity. Preserve user work and local board
+customizations; do not reset or overwrite a dirty tree.
+
+Success is not merely a successful flash: the board must boot, mount storage,
+return `/api/sysinfo`, expose required internal apps, and accept an external
+app rebuilt against this exact firmware.
+
+## Upgrade and customization audit
+
+1. Fetch and compare the intended upstream branch before merging. Treat
+   `upstream/main` as distinct from experimental release/IDF branches unless
+   the task explicitly asks for one of those branches.
+2. Merge without discarding local work (for example, `git merge --autostash
+   upstream/main` after inspecting status). Resolve conflicts by preserving
+   required ES3C28P and ES3C35P device definitions, partition selection,
+   display/font customizations, and product features.
+3. Compare the pre-upgrade customization commit against the resulting worktree.
+   Check new app registrations, CMake/source inclusion, settings pages,
+   web-server endpoints, and board-specific `sdkconfig` entries—not just files
+   that happen to conflict.
+4. Commit the resulting firmware customization as a focused, reviewable
+   commit after `git diff --check`.
+
+## Multi-binary external-app compatibility
+
+Upstream app packaging changed to `bin/<platform>/<binary>.elf`. The old
+`elf/<platform>.elf` archive layout produces a loader `Not executable` error.
+
+- Manifest v0.2: `bin/esp32s3/app.elf`
+- Manifest v0.3: `bin/esp32s3/<app.0.binary>.elf`
+
+When this change arrives, update the companion app tool and rebuild every app
+from a fresh SDK exported from this firmware. Do not attempt to repair a
+packaged ELF on the SD card: its layout and ABI must both be regenerated.
+
+## Build and flash
+
+Use the installed IDF 5.5 environment; host virtual environments can corrupt
+both Python dependencies and IDF tooling:
+
+```zsh
+unset VIRTUAL_ENV PYTHONPATH PYTHONHOME
+export IDF_PYTHON_ENV_PATH=/Users/adolforeyna/.espressif/python_env/idf5.5_py3.9_env
+source /Users/adolforeyna/esp/esp-idf/export.sh
+
+# Select/check the intended board before this step.
+python device.py <device-id>
+idf.py build
+idf.py -p /dev/cu.usbmodemXXXX flash
+```
+
+`Tactility/CMakeLists.txt` uses a non-configure-dependent source glob. After
+adding a new `.c`/`.cpp` file, run `idf.py reconfigure build`; otherwise a
+linker error for a newly referenced symbol may only mean CMake has not
+discovered the source file yet.
+
+## Boot and feature acceptance
+
+Capture serial at 115200 after flash or reset. Confirm the board name, SD-card
+mount, HTTP-server start, Wi-Fi address, and any feature-specific startup logs.
+Then query the resolved device:
+
+```zsh
+curl -fsS http://<ip>/api/sysinfo
+curl -fsS http://<ip>/api/apps
+```
+
+For MCP settings, verify the `McpSettings` internal app appears in `/api/apps`.
+When enabled, verify MCP stream startup logs. For a feature restored from an
+older customization, validate its registration path and persisted settings,
+not only its source files.
+
+## External-app acceptance gate
+
+Use the companion app skill's exact-firmware wrapper:
+
+```zsh
+cd /path/to/tactility_apps
+scripts/build_current_firmware_app.sh Apps/MyApp --firmware /path/to/tactility
+```
+
+Inspect the resulting tar member path, install through port-80 dashboard API,
+launch it, and read serial. Required evidence is the loader's `Loading
+.../bin/...`, an ELF entry address, `Task started`, and app-specific startup
+logs. HTTP 200 or a package simply appearing in `/api/apps` is insufficient.
+
+## Host simulator (buildsim) + web viewer
+
+The POSIX simulator runs the real firmware (LVGL, services, web server) on
+macOS/Linux with an SDL backend. On current firmware, `Main.cpp` runs SDL's
+event loop on the process main thread while FreeRTOS runs on a separate thread.
+This is required by AppKit and supports a native macOS window as well as the
+web viewer. `SDL_VIDEODRIVER=dummy` remains useful for headless automation.
+
+Code locations:
+
+- `Devices/simulator/Source/module.cpp` — display resolution + `SIM_DISPLAY_W/H`
+- `Devices/simulator/Source/drivers/sdl_display.{h,cpp}` — SDL backend
+- `Devices/simulator/Source/drivers/sdl_input.{h,cpp}` — pointer/key state +
+  web touch-injection override
+- `Tactility/Source/service/webserver/WebServerService.cpp` — `/sim` viewer,
+  `/sim/api/*` aliases, `POST /api/sim/touch`, `GET /api/screenshot?fast=`
+- `Tactility/Private/Tactility/service/webserver/WebServerService.h` — handler decls
+
+### Build and run
+
+```zsh
+# one-time host deps (outside any ESP-IDF env)
+mkdir -p /tmp/simbin && ln -sf "$(which python3)" /tmp/simbin/python
+pip3 install --break-system-packages lark pyyaml   # devicetree compiler
+
+cd /path/to/tactility
+export PATH="/tmp/simbin:$PATH"
+env -u ESP_IDF_VERSION -u IDF_PATH cmake -S . -B buildsim -DCMAKE_BUILD_TYPE=Release
+env -u ESP_IDF_VERSION -u IDF_PATH cmake --build buildsim --target Tactility -j "$(sysctl -n hw.ncpu)"
+
+# POSIX SDK for host apps (arm64)
+env -u ESP_IDF_VERSION -u IDF_PATH cmake --build buildsim --target TactilityKernel lvgl minitar minmea \
+  app-module crypt-module gps-module http-module lvgl-module lvgl-window-manager-module service-module
+env -u ESP_IDF_VERSION -u IDF_PATH python3 Buildscripts/release-sdk-posix.py /tmp/sim-sdk
+
+# release (MUST run from the firmware root: release-simulator.sh uses relative
+# version.txt / Data paths)
+sh Buildscripts/release-simulator.sh buildsim /tmp/simrun
+# Native macOS window + web API. Run this from the release directory because
+# data/ and system/ are relative to the process working directory.
+(cd /tmp/simrun && SIM_DISPLAY_W=480 SIM_DISPLAY_H=320 \
+  nohup ./Tactility > /tmp/sim_gui.log 2>&1 &)
+# For CI/headless operation, set SDL_VIDEODRIVER=dummy instead.
+curl -s --max-time 5 http://127.0.0.1/api/sysinfo | head -c 120
+```
+
+Display resolution: `SIM_DISPLAY_W/H` env (default **480x320 landscape**,
+matching on-device screenshots). ES3C35P panel is 320x480 portrait in DTS but
+presents 480x320 landscape; ES3C28P is 320x240. The chosen geometry is logged
+as `Simulator Sim display WxH`. `SDL_VIDEODRIVER=dummy` is expected to log one
+`SdlDisplay Failed to create SDL window: Couldn't find matching render
+driver` line — LVGL still renders and screenshots work. A native macOS launch
+must not emit that line.
+
+### Web viewer, touch, screenshots
+
+- `GET /sim` → 301 to `/sim/` (trailing slash required so the page's relative
+  `api/` URLs resolve under `/sim/`). Viewer polls `api/screenshot?fast=1`
+  every 500 ms, footer shows live `naturalWidth×naturalHeight`, click/tap
+  POSTs `api/sim/touch?x=&y=`.
+- `POST /api/sim/touch?x=123&y=456[&down=0|1]` (also `/sim/api/sim/touch` via
+  alias). Coordinates are LVGL logical pixels. `down=1` (default) presses and
+  **auto-releases after 1500 ms** (`SIM_TOUCH_HOLD_MS` in `sdl_input.cpp`),
+  long enough for LVGL indev polls to register a click. Simulator-only: 404 on
+  ESP32 (`#ifndef ESP_PLATFORM`).
+- `GET /api/screenshot?fast=1` (default): `lv_snapshot_take` (RGB888) → in-place
+  BGR→RGB swap → `lodepng_encode24` **to memory** → chunked HTTP. No filesystem
+  touch, ~8 ms/shot. `?fast=0` keeps the legacy `webscreenshotN.png` file path
+  (slot scan + accumulation — avoid for viewer loops).
+- lodepng include in `.cpp`: `#define LODEPNG_NO_COMPILE_CPP` before
+  `#include "src/libs/lodepng/lodepng.h"`, otherwise its C++ `std::vector`
+  overloads collide with the C declarations (`conflicting types for 'encode'`).
+- MCP includes and `settings::mcp` reads are `#ifdef ESP_PLATFORM`-gated; the
+  sim has no `McpSystem`.
+
+### Tailscale viewer
+
+```zsh
+tailscale serve --bg --set-path=/simagent http://127.0.0.1:80/
+# open: https://<node>/simagent/sim/
+```
+
+The serve target must be `/` (not `/sim`): the page resolves `api/` against
+its own directory, so at `/simagent/sim/` fetches go to `/simagent/sim/api/…`,
+which tailscale strips to `/sim/api/…` and the firmware's `/sim/api/*`
+aliases (GET+POST, registered in `startServer()`) handle. Absolute `/api/…`
+URLs would 404 at the edge (no `/api` mount there).
+
+### Simulator pitfalls
+
+- **Rebuild ≠ redeploy.** `cmake --build buildsim` updates `buildsim/` only.
+  Re-run `release-simulator.sh`, restart the process, then retest. A stale
+  `/tmp/simrun/Tactility` serves old handlers with new logs nowhere to be found.
+- **One simulator owns port 80.** Do not launch a second instance while another
+  simulator is listening: it will initialize LVGL but fail `bind/listen`, so its
+  app API and viewer target the other process. Identify the listener with
+  `lsof -nP -iTCP:80 -sTCP:LISTEN`, stop only the intended simulator, then
+  release/restart it before installing or running POSIX apps.
+- **Input is cross-thread on macOS.** SDL event pumping occurs on the real main
+  thread; LVGL and web touch injection run elsewhere. Keep all shared pointer,
+  key-queue, and touch-override state under `sdl_input.cpp`'s mutex.
+- **C array `sizeof` decay.** A helper like
+  `f(HttpServerRequest*, char uri[256])` sees `sizeof(uri) == 8`, truncating
+  `get_uri` output to 7 chars (`/api/sy`, `/sim/ap` 404s). Pass the size
+  explicitly: `f(request, buf, sizeof(buf))`.
+- **Log truncation.** `LOG_QUEUE_MESSAGE_MAX_LENGTH` is 256 (`TactilityKernel/
+  private/tactility/log_queue.h`), including color/timestamp prefix. Long URIs
+  and messages truncate — don't over-interpret a short path in the log.
+- **Auth.** The viewer and API handlers enforce `validateRequestAuth` like any
+  other endpoint; failures surface as 401/404, not viewer bugs.

.github/actions/build-simulator/action.yml

@@ -4,11 +4,8 @@ inputs:
   os_name:
     description: A descriptive name for the operating system (e.g. linux, windows)
     required: true
-  platform_name:
-    description: A descriptive name for the target platform (e.g. amd64, aarch64, etc.)
-    required: true
-  publish:
-    description: A boolean that enables publishing of artifacts
+  architecture:
+    description: A descriptive name for the target architecture (e.g. x86_64, aarch64, etc.)
     required: true
 
 runs:
@@ -48,11 +45,10 @@ runs:
       run: cmake --build buildsim --target Tactility
     - name: 'Release'
       shell: bash
-      run: Buildscripts/release-simulator.sh buildsim release/Simulator-${{ inputs.os_name }}-${{ inputs.platform_name }}
+      run: Buildscripts/release-simulator.sh buildsim release/Simulator-${{ inputs.os_name }}-${{ inputs.architecture }}
     - name: 'Upload Artifact'
       uses: actions/upload-artifact@v4
-      if: ${{ inputs.publish == 'true' }}
       with:
-        name: Simulator-${{ inputs.os_name }}-${{ inputs.platform_name }}
-        path: release/Simulator-${{ inputs.os_name }}-${{ inputs.platform_name }}
+        name: Simulator-${{ inputs.os_name }}-${{ inputs.architecture }}
+        path: release/Simulator-${{ inputs.os_name }}-${{ inputs.architecture }}
         retention-days: 30

.github/workflows/build-simulator.yml

@@ -17,8 +17,7 @@ jobs:
         uses: ./.github/actions/build-simulator
         with:
           os_name: linux
-          platform_name: amd64
-          publish: true
+          architecture: x86_64
   macOS:
     runs-on: macos-latest
     steps:
@@ -29,6 +28,4 @@ jobs:
         uses: ./.github/actions/build-simulator
         with:
           os_name: macos
-          platform_name: aarch64
-          # macOS simulator currently fails due to main thread requirement for rendering
-          publish: false
+          architecture: aarch64

.gitignore

@@ -3,6 +3,8 @@
 
 build*/
 !.github/actions/build*/
+!Buildscripts/
+!Buildscripts/release-simulator-macos-app.sh
 cmake*/
 CMakeCache.txt
 *.cbp
@@ -27,4 +29,4 @@ sdkconfig.board.*.dev
 .caveman.json
 .ai/mcp
 
-__pycache__
+__pycache__

Buildscripts/release-simulator-macos-app.sh

@@ -0,0 +1,63 @@
+#!/bin/sh
+
+# Usage: release-simulator-macos-app.sh [builddir] [Tactility.app]
+# Example: release-simulator-macos-app.sh buildsim release/Tactility.app
+
+set -eu
+
+build_path=$1
+bundle_path=$2
+
+if [ -e "$bundle_path" ]; then
+    echo "Refusing to overwrite existing bundle: $bundle_path" >&2
+    exit 1
+fi
+
+contents_path="$bundle_path/Contents"
+resources_path="$contents_path/Resources"
+macos_path="$contents_path/MacOS"
+
+mkdir -p "$resources_path" "$macos_path"
+
+cp "$build_path/Tactility/Tactility" "$resources_path/Tactility-bin"
+cp version.txt "$resources_path/"
+cp -R Data/data "$resources_path/"
+cp -R Data/system "$resources_path/"
+
+cat > "$contents_path/Info.plist" <<'EOF'
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>CFBundleDevelopmentRegion</key>
+    <string>en</string>
+    <key>CFBundleExecutable</key>
+    <string>Tactility</string>
+    <key>CFBundleIdentifier</key>
+    <string>org.tactilityproject.simulator</string>
+    <key>CFBundleInfoDictionaryVersion</key>
+    <string>6.0</string>
+    <key>CFBundleName</key>
+    <string>Tactility</string>
+    <key>CFBundlePackageType</key>
+    <string>APPL</string>
+    <key>CFBundleShortVersionString</key>
+    <string>0.8.0-dev</string>
+    <key>CFBundleVersion</key>
+    <string>1</string>
+    <key>NSMicrophoneUsageDescription</key>
+    <string>Tactility uses the microphone when a simulator app records audio.</string>
+</dict>
+</plist>
+EOF
+
+cat > "$macos_path/Tactility" <<'EOF'
+#!/bin/sh
+set -eu
+
+resources_path="$(CDPATH= cd -- "$(dirname -- "$0")/../Resources" && pwd)"
+cd "$resources_path"
+exec "$resources_path/Tactility-bin" "$@"
+EOF
+
+chmod +x "$macos_path/Tactility" "$resources_path/Tactility-bin"

CMakeLists.txt

@@ -62,9 +62,13 @@ if (DEFINED ENV{ESP_IDF_VERSION})
     # to every target; PanicHandler.cpp branches internally per architecture.
     idf_build_set_property(LINK_OPTIONS "-Wl,--wrap=esp_panic_handler" APPEND)
 
-    idf_build_set_property(LINK_OPTIONS "-Wl,--wrap=read" APPEND)
-    idf_build_set_property(LINK_OPTIONS "-Wl,--wrap=write" APPEND)
-    idf_build_set_property(LINK_OPTIONS "-Wl,--wrap=close" APPEND)
+    # Wraps newlib's reentrant syscall stubs, not the plain read()/write()/close() newlib itself
+    # implements as thin wrappers around them. newlib's own stdio (fflush()'s buffer-flush path in particular)
+    # calls these _r stubs directly, bypassing the plain names entirely.
+    # See Modules/app-module/source/stdio_wrap.cpp's own comment for the exact call chain.
+    idf_build_set_property(LINK_OPTIONS "-Wl,--wrap=_read_r" APPEND)
+    idf_build_set_property(LINK_OPTIONS "-Wl,--wrap=_write_r" APPEND)
+    idf_build_set_property(LINK_OPTIONS "-Wl,--wrap=_close_r" APPEND)
 
     idf_build_set_property(LINK_OPTIONS "-Wl,--wrap=lv_button_create" APPEND)
     idf_build_set_property(LINK_OPTIONS "-Wl,--wrap=lv_dropdown_create" APPEND)
@@ -106,6 +110,9 @@ endif ()
 
 # Defined as regular project for PC and component for ESP
 if (NOT DEFINED ENV{ESP_IDF_VERSION})
+    if (APPLE)
+        enable_language(OBJC OBJCXX)
+    endif ()
     add_subdirectory(Tactility)
     add_subdirectory(TactilityFreeRtos)
     add_subdirectory(TactilityKernel)
@@ -133,6 +140,7 @@ if (NOT DEFINED ENV{ESP_IDF_VERSION})
     add_subdirectory(Modules/lvgl-window-manager-module)
     add_subdirectory(Drivers/gps-generic-module)
     add_subdirectory(Drivers/gps-meshtastic-module)
+    add_subdirectory(Drivers/audio-stream-module)
 
     # FreeRTOS
     set(FREERTOS_CONFIG_FILE_DIRECTORY ${PROJECT_SOURCE_DIR}/Devices/simulator/Source CACHE STRING "")

Data/data/tactility/service/webserver/settings.properties

@@ -17,7 +17,7 @@ apOpenNetwork=0
 apChannel=1
 
 # Web Server Settings
-webServerEnabled=0
+webServerEnabled=1
 webServerPort=80
 
 # HTTP Basic Authentication (optional)

Devices/es3c28p/device.properties

@@ -19,3 +19,8 @@ display.dpi=143
 lvgl.colorDepth=16
 
 storage.userDataLocation=SD
+
+# Launcher clock and full-screen wallpaper
+sdkconfig.CONFIG_LV_FONT_MONTSERRAT_48=y
+sdkconfig.CONFIG_LV_CACHE_DEF_SIZE=1048576
+sdkconfig.CONFIG_LV_IMAGE_HEADER_CACHE_DEF_CNT=16

Devices/es3c28p/es3c28p.dts

@@ -90,6 +90,7 @@
 			compatible = "everest,es8311";
 			reg = <0x18>;
 			i2s = <&i2s0>;
+			input-gain-percent = <100>;
 		};
 	};
 

Devices/es3c35p/device.properties

@@ -16,6 +16,7 @@ display.shape=rectangle
 display.dpi=165
 
 lvgl.colorDepth=16
+lvgl.fontSize=16
 
 storage.userDataLocation=SD
 

Devices/es3c35p/es3c35p.dts

@@ -86,6 +86,7 @@
 			compatible = "everest,es8311";
 			reg = <0x18>;
 			i2s = <&i2s0>;
+			input-gain-percent = <100>;
 		};
 	};
 

Devices/simulator/CMakeLists.txt

@@ -21,4 +21,13 @@ if (NOT DEFINED ENV{ESP_IDF_VERSION})
 
     target_link_libraries(simulator PRIVATE ${SDL2_LIBRARIES})
 
+    if (APPLE)
+        target_sources(simulator PRIVATE Source/drivers/sdl_audio_permission.mm)
+        target_link_libraries(simulator PRIVATE "-framework AVFoundation" "-framework Foundation")
+        # The developer executable can also request recording outside an .app bundle.
+        target_link_options(simulator INTERFACE
+            "LINKER:-sectcreate,__TEXT,__info_plist,${CMAKE_CURRENT_SOURCE_DIR}/macos-info.plist")
+        set_property(TARGET Tactility APPEND PROPERTY LINK_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/macos-info.plist")
+    endif ()
+
 endif()

Devices/simulator/Source/Main.cpp

@@ -10,13 +10,13 @@ constexpr auto* TAG = "FreeRTOS";
 
 namespace simulator {
 
-MainFunction mainFunction = nullptr;
+static MainFunction mainFunction = nullptr;
 
 void setMain(MainFunction newMainFunction) {
     mainFunction = newMainFunction;
 }
 
-static void freertosMainTask(void* parameter) {
+static void freertosMainTask(void*) {
     LOG_I(TAG, "starting app_main()");
     assert(simulator::mainFunction);
     mainFunction();

Devices/simulator/Source/Simulator.h

@@ -1,6 +1,11 @@
 #pragma once
 
 #include "Main.h"
+#include "drivers/sdl_bridge.h"
+
+#include <csignal>
+#include <pthread.h>
+#include <thread>
 
 namespace simulator {
     /** Set the function pointer of the real app_main() */
@@ -14,8 +19,23 @@ void app_main(); // ESP-IDF's main function, implemented in the application
 }
 
 int main() {
-    // Actual main function that passes on app_main() (to be executed in a FreeRTOS task) and bootstraps FreeRTOS
+    // The FreeRTOS POSIX port arms a process-wide SIGALRM timer for its tick and expects every one
+    // of its task pthreads to have all signals but SIGINT blocked.
+    // (see prvSetupSignalsAndSchedulerPolicy() in FreeRTOS-Kernel's Posix port.c)
+    // A signal-generated SIGALRM can land on any thread in the process that doesn't block it.
+    // This thread stays a plain OS thread (running the SDL loop below, never a FreeRTOS task),
+    // so without this it's eligible to catch a tick SIGALRM and freeze inside the scheduler's handler.
+    // Block the same set here, before anything else, so it never can.
+    sigset_t all_signals_except_sigint;
+    sigfillset(&all_signals_except_sigint);
+    sigdelset(&all_signals_except_sigint, SIGINT);
+    pthread_sigmask(SIG_SETMASK, &all_signals_except_sigint, nullptr);
+
+    // FreeRTOS and app_main() run on a separate thread: macOS requires SDL/Cocoa window creation,
+    // event pumping and rendering to happen on the real OS main thread, which sdl_bridge_run_main_loop()
+    // below takes over. freertosMain() never returns, so this thread is detached rather than joined.
     simulator::setMain(app_main);
-    simulator::freertosMain();
+    std::thread(simulator::freertosMain).detach();
+    sdl_bridge_run_main_loop();
     return 0;
 }

Devices/simulator/Source/drivers/sdl_audio.cpp

@@ -0,0 +1,325 @@
+// SPDX-License-Identifier: Apache-2.0
+#include "sdl_audio.h"
+#include "sdl_audio_buffer.h"
+
+#include <tactility/device.h>
+#include <tactility/driver.h>
+#include <tactility/freertos/task.h>
+#include <tactility/log.h>
+#include <tactility/module.h>
+
+#include <SDL2/SDL.h>
+#include <atomic>
+#include <cmath>
+#include <cstdlib>
+#include <cstring>
+#include <new>
+
+namespace {
+
+constexpr auto* TAG = "SdlAudio";
+constexpr uint32_t SAMPLE_RATE = 48000;
+
+struct AudioData {
+    SdlAudioBuffer buffer;
+    SemaphoreHandle_t mutex = nullptr; // task-side only; never used by the SDL callback
+    SDL_AudioDeviceID id = 0;
+    AudioCodecDirection direction;
+    std::atomic<float> volume { 100.0f };
+    std::atomic<bool> muted { false };
+    std::atomic<uint32_t> callbacks { 0 };
+};
+
+AudioData* get_data(Device* device) {
+    return static_cast<AudioData*>(device_get_driver_data(device));
+}
+
+class Lock {
+    SemaphoreHandle_t mutex;
+public:
+    explicit Lock(AudioData* data) : mutex(data->mutex) { xSemaphoreTake(mutex, portMAX_DELAY); }
+    ~Lock() { xSemaphoreGive(mutex); }
+};
+
+const char* device_name(const AudioData* data) {
+    const char* name = std::getenv(data->direction == AUDIO_CODEC_DIR_INPUT ? "SIM_AUDIO_INPUT" : "SIM_AUDIO_OUTPUT");
+    return name != nullptr && name[0] != '\0' ? name : nullptr;
+}
+
+bool available(const AudioData* data) {
+    const char* name = device_name(data);
+    if (name != nullptr && std::strcmp(name, "none") == 0) return false;
+    const int capture = data->direction == AUDIO_CODEC_DIR_INPUT;
+    const int count = SDL_GetNumAudioDevices(capture);
+    if (name == nullptr) return count > 0;
+    for (int i = 0; i < count; ++i) {
+        const char* candidate = SDL_GetAudioDeviceName(i, capture);
+        if (candidate != nullptr && std::strcmp(candidate, name) == 0) return true;
+    }
+    return false;
+}
+
+void apply_volume(AudioData* data, void* bytes, size_t size) {
+    const float gain = data->muted.load() ? 0.0f : data->volume.load() / 100.0f;
+    auto* output = static_cast<uint8_t*>(bytes);
+    for (size_t i = 0; i < size; i += sizeof(int16_t)) {
+        int16_t sample;
+        std::memcpy(&sample, output + i, sizeof(sample));
+        sample = static_cast<int16_t>(sample * gain);
+        std::memcpy(output + i, &sample, sizeof(sample));
+    }
+}
+
+void audio_callback(void* context, Uint8* stream, int length) {
+    auto* data = static_cast<AudioData*>(context);
+    const size_t count = static_cast<size_t>(length) / sizeof(int16_t);
+    if (data->direction == AUDIO_CODEC_DIR_INPUT) {
+        // Drop incoming frames when the bounded capture buffer is full. Muted capture
+        // must not leave real microphone samples queued for a later unmute.
+        if (data->muted.load()) std::memset(stream, 0, length);
+        data->buffer.write(stream, count);
+    } else {
+        const size_t copied = data->buffer.read(stream, count) * sizeof(int16_t);
+        std::memset(stream + copied, 0, length - copied); // silence on underrun
+        apply_volume(data, stream, copied);
+    }
+    data->callbacks.fetch_add(1, std::memory_order_relaxed);
+}
+
+error_t start(Device* device) {
+    const auto* config = static_cast<const SdlAudioConfig*>(device->config);
+    if (config == nullptr || (config->direction != AUDIO_CODEC_DIR_INPUT && config->direction != AUDIO_CODEC_DIR_OUTPUT)) {
+        return ERROR_INVALID_ARGUMENT;
+    }
+    if (SDL_InitSubSystem(SDL_INIT_AUDIO) != 0) {
+        LOG_E(TAG, "Cannot initialize audio: %s", SDL_GetError());
+        return ERROR_RESOURCE;
+    }
+    auto* data = new (std::nothrow) AudioData;
+    if (data == nullptr) {
+        SDL_QuitSubSystem(SDL_INIT_AUDIO);
+        return ERROR_OUT_OF_MEMORY;
+    }
+    data->direction = config->direction;
+    data->mutex = xSemaphoreCreateMutex();
+    if (data->mutex == nullptr) {
+        delete data;
+        SDL_QuitSubSystem(SDL_INIT_AUDIO);
+        return ERROR_OUT_OF_MEMORY;
+    }
+    device_set_driver_data(device, data);
+    const int capture = data->direction == AUDIO_CODEC_DIR_INPUT;
+    for (int i = 0; i < SDL_GetNumAudioDevices(capture); ++i) {
+        LOG_I(TAG, "%s device: %s", capture ? "Input" : "Output", SDL_GetAudioDeviceName(i, capture));
+    }
+    LOG_I(TAG, "%s: %s (%s)", device->name, device_name(data) != nullptr ? device_name(data) : "system default",
+        available(data) ? "available" : "unavailable");
+    return ERROR_NONE;
+}
+
+error_t open(Device* device, const AudioCodecStreamConfig* config) {
+    auto* data = get_data(device);
+    if (config == nullptr) return ERROR_INVALID_ARGUMENT;
+    if (config->direction != data->direction) return ERROR_NOT_SUPPORTED;
+    // The shared stream module performs rate/channel conversion on S16 PCM.
+    if (config->bits_per_sample != 16) return ERROR_NOT_SUPPORTED;
+    const uint8_t channels = data->direction == AUDIO_CODEC_DIR_INPUT ? 1 : 2;
+    if (config->sample_rate != SAMPLE_RATE || config->channels != channels) return ERROR_INVALID_ARGUMENT;
+    Lock lock(data);
+    if (data->id != 0) return ERROR_INVALID_STATE;
+    if (!available(data)) {
+        LOG_W(TAG, "No selected %s device available", data->direction == AUDIO_CODEC_DIR_INPUT ? "input" : "output");
+        return ERROR_NOT_SUPPORTED;
+    }
+#ifdef __APPLE__
+    // Only ask when recording is requested, and only with real macOS audio (dummy
+    // and disk backends are also useful for automated tests).
+    if (data->direction == AUDIO_CODEC_DIR_INPUT && std::strcmp(SDL_GetCurrentAudioDriver(), "coreaudio") == 0) {
+        error_t permission;
+        while ((permission = sdl_audio_microphone_permission()) == ERROR_RESOURCE_BUSY) vTaskDelay(1);
+        if (permission != ERROR_NONE) {
+            LOG_W(TAG, "Microphone permission denied; enable access in macOS Privacy & Security > Microphone");
+            return permission;
+        }
+    }
+#endif
+    SDL_AudioSpec wanted {};
+    wanted.freq = SAMPLE_RATE;
+    wanted.format = AUDIO_S16SYS;
+    wanted.channels = channels;
+    wanted.samples = 512;
+    wanted.callback = audio_callback;
+    wanted.userdata = data;
+    data->buffer.reset();
+    data->callbacks.store(0);
+    // No allowed changes: SDL converts between our fixed PCM format and the host
+    // device's format when necessary. No hardware-specific format leaks to apps.
+    data->id = SDL_OpenAudioDevice(device_name(data), data->direction == AUDIO_CODEC_DIR_INPUT, &wanted, nullptr, 0);
+    if (data->id == 0) {
+        LOG_E(TAG, "Cannot open %s: %s", device->name, SDL_GetError());
+        return ERROR_RESOURCE;
+    }
+    SDL_PauseAudioDevice(data->id, 0);
+    return ERROR_NONE;
+}
+
+error_t close(Device* device) {
+    auto* data = get_data(device);
+    Lock lock(data);
+    if (data->id != 0) {
+        // Preserve the end of short sounds. Drain is bounded even if the device has
+        // disappeared; microphone close never waits for the capture buffer to empty.
+        const TickType_t start = xTaskGetTickCount();
+        while (data->direction == AUDIO_CODEC_DIR_OUTPUT && !data->buffer.empty()
+            && xTaskGetTickCount() - start < pdMS_TO_TICKS(250)
+            && SDL_GetAudioDeviceStatus(data->id) == SDL_AUDIO_PLAYING) {
+            vTaskDelay(1);
+        }
+        SDL_CloseAudioDevice(data->id);
+        data->id = 0;
+        data->buffer.reset();
+    }
+    return ERROR_NONE;
+}
+
+error_t stop(Device* device) {
+    auto* data = get_data(device);
+    close(device);
+    vSemaphoreDelete(data->mutex);
+    delete data;
+    device_set_driver_data(device, nullptr);
+    SDL_QuitSubSystem(SDL_INIT_AUDIO);
+    return ERROR_NONE;
+}
+
+error_t transfer(Device* device, void* destination, const void* source, size_t size, size_t* transferred, TickType_t timeout, bool capture) {
+    if (transferred != nullptr) *transferred = 0;
+    auto* data = get_data(device);
+    if ((data->direction == AUDIO_CODEC_DIR_INPUT) != capture) return ERROR_NOT_SUPPORTED;
+    const size_t frame_size = sizeof(int16_t) * (capture ? 1 : 2);
+    if (size % frame_size != 0 || (size != 0 && (capture ? destination == nullptr : source == nullptr))) return ERROR_INVALID_ARGUMENT;
+    Lock lock(data);
+    if (data->id == 0) return ERROR_INVALID_STATE;
+    const TickType_t start = xTaskGetTickCount();
+    TickType_t last_callback = start;
+    uint32_t callbacks = data->callbacks.load();
+    size_t done = 0;
+    error_t result = ERROR_NONE;
+    while (done < size) {
+        if (SDL_GetAudioDeviceStatus(data->id) != SDL_AUDIO_PLAYING) {
+            result = ERROR_RESOURCE;
+            break;
+        }
+        const size_t count = (size - done) / sizeof(int16_t);
+        const size_t copied = capture
+            ? data->buffer.read(static_cast<uint8_t*>(destination) + done, count)
+            : data->buffer.write(static_cast<const uint8_t*>(source) + done, count);
+        done += copied * sizeof(int16_t);
+        if (done == size) break;
+        const TickType_t now = xTaskGetTickCount();
+        if (timeout != portMAX_DELAY && now - start >= timeout) {
+            result = ERROR_TIMEOUT;
+            break;
+        }
+        const uint32_t current_callbacks = data->callbacks.load();
+        if (current_callbacks != callbacks) {
+            callbacks = current_callbacks;
+            last_callback = now;
+        } else if (now - last_callback >= pdMS_TO_TICKS(2000)) {
+            // A stopped backend must not strand an infinite-timeout caller or a
+            // concurrent Settings disable waiting for that caller to finish.
+            result = ERROR_RESOURCE;
+            break;
+        }
+        vTaskDelay(1);
+    }
+    if (capture) apply_volume(data, destination, done);
+    if (transferred != nullptr) *transferred = done;
+    return result;
+}
+
+error_t read(Device* device, void* destination, size_t size, size_t* count, TickType_t timeout) {
+    return transfer(device, destination, nullptr, size, count, timeout, true);
+}
+
+error_t write(Device* device, const void* source, size_t size, size_t* count, TickType_t timeout) {
+    return transfer(device, nullptr, source, size, count, timeout, false);
+}
+
+error_t set_volume(Device* device, AudioCodecDirection direction, float volume) {
+    auto* data = get_data(device);
+    if (direction != data->direction) return ERROR_NOT_SUPPORTED;
+    if (!std::isfinite(volume) || volume < 0.0f || volume > 100.0f) return ERROR_INVALID_ARGUMENT;
+    data->volume.store(volume);
+    return ERROR_NONE;
+}
+
+error_t get_volume(Device* device, AudioCodecDirection direction, float* volume) {
+    auto* data = get_data(device);
+    if (direction != data->direction) return ERROR_NOT_SUPPORTED;
+    *volume = data->volume.load();
+    return ERROR_NONE;
+}
+
+error_t set_mute(Device* device, AudioCodecDirection direction, bool muted) {
+    auto* data = get_data(device);
+    if (direction != data->direction) return ERROR_NOT_SUPPORTED;
+    data->muted.store(muted);
+    return ERROR_NONE;
+}
+
+error_t get_mute(Device* device, AudioCodecDirection direction, bool* muted) {
+    auto* data = get_data(device);
+    if (direction != data->direction) return ERROR_NOT_SUPPORTED;
+    *muted = data->muted.load();
+    return ERROR_NONE;
+}
+
+error_t get_rate(Device* device, AudioCodecDirection direction, uint32_t* rate) {
+    if (direction != get_data(device)->direction) return ERROR_NOT_SUPPORTED;
+    *rate = SAMPLE_RATE;
+    return ERROR_NONE;
+}
+
+error_t get_channels(Device* device, AudioCodecDirection direction, uint8_t* channels) {
+    if (direction != get_data(device)->direction) return ERROR_NOT_SUPPORTED;
+    *channels = direction == AUDIO_CODEC_DIR_INPUT ? 1 : 2;
+    return ERROR_NONE;
+}
+
+error_t get_capabilities(Device* device, AudioCodecDirection* direction) {
+    auto* data = get_data(device);
+    if (!available(data)) return ERROR_NOT_SUPPORTED;
+    *direction = data->direction;
+    return ERROR_NONE;
+}
+
+const AudioCodecApi api = {
+    .open = open,
+    .close = close,
+    .read = read,
+    .write = write,
+    .set_volume = set_volume,
+    .get_volume = get_volume,
+    .set_mute = set_mute,
+    .get_mute = get_mute,
+    .get_native_sample_rate = get_rate,
+    .get_native_channels = get_channels,
+    .get_capabilities = get_capabilities,
+    .get_input_gain_multiplier = nullptr,
+};
+
+} // namespace
+
+extern "C" Module simulator_module;
+
+Driver sdl_audio_driver = {
+    .name = "sdl-audio",
+    .compatible = (const char*[]) { "tactility,sdl-audio", nullptr },
+    .start_device = start,
+    .stop_device = stop,
+    .api = &api,
+    .device_type = &AUDIO_CODEC_TYPE,
+    .owner = &simulator_module,
+    .internal = nullptr,
+};

Devices/simulator/Source/drivers/sdl_audio.h

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+
+#include <tactility/drivers/audio_codec.h>
+
+struct SdlAudioConfig {
+    AudioCodecDirection direction;
+};
+
+#ifdef __APPLE__
+// Nonblocking: ERROR_RESOURCE_BUSY means that the user has not answered the prompt yet.
+error_t sdl_audio_microphone_permission();
+#endif

Devices/simulator/Source/drivers/sdl_audio_buffer.h

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+
+#include <algorithm>
+#include <array>
+#include <atomic>
+#include <cstdint>
+#include <cstring>
+
+// Single producer / single consumer. The SDL callback is a native thread: it must never
+// allocate, block, log, or call FreeRTOS. Unsigned counters also work across wraparound.
+class SdlAudioBuffer {
+    static constexpr uint32_t CAPACITY = 16384; // samples; ~171 ms of 48 kHz stereo
+    std::array<int16_t, CAPACITY> samples {};
+    std::atomic<uint32_t> read_position { 0 };
+    std::atomic<uint32_t> write_position { 0 };
+
+public:
+    size_t write(const void* source, size_t count) {
+        const uint32_t write = write_position.load(std::memory_order_relaxed);
+        const uint32_t read = read_position.load(std::memory_order_acquire);
+        count = std::min(count, static_cast<size_t>(CAPACITY - (write - read)));
+        const size_t first = std::min(count, static_cast<size_t>(CAPACITY - write % CAPACITY));
+        const auto* bytes = static_cast<const uint8_t*>(source);
+        std::memcpy(samples.data() + write % CAPACITY, bytes, first * sizeof(int16_t));
+        std::memcpy(samples.data(), bytes + first * sizeof(int16_t), (count - first) * sizeof(int16_t));
+        write_position.store(write + count, std::memory_order_release);
+        return count;
+    }
+
+    size_t read(void* destination, size_t count) {
+        const uint32_t read = read_position.load(std::memory_order_relaxed);
+        const uint32_t write = write_position.load(std::memory_order_acquire);
+        count = std::min(count, static_cast<size_t>(write - read));
+        const size_t first = std::min(count, static_cast<size_t>(CAPACITY - read % CAPACITY));
+        auto* bytes = static_cast<uint8_t*>(destination);
+        std::memcpy(bytes, samples.data() + read % CAPACITY, first * sizeof(int16_t));
+        std::memcpy(bytes + first * sizeof(int16_t), samples.data(), (count - first) * sizeof(int16_t));
+        read_position.store(read + count, std::memory_order_release);
+        return count;
+    }
+
+    bool empty() const {
+        return read_position.load(std::memory_order_acquire) == write_position.load(std::memory_order_acquire);
+    }
+
+    // Only while the SDL device is closed and no caller is doing I/O.
+    void reset() {
+        read_position.store(0);
+        write_position.store(0);
+    }
+};

Devices/simulator/Source/drivers/sdl_audio_permission.mm

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: Apache-2.0
+#include "sdl_audio.h"
+
+#import <AVFoundation/AVFoundation.h>
+#include <atomic>
+
+error_t sdl_audio_microphone_permission() {
+    @autoreleasepool {
+        switch ([AVCaptureDevice authorizationStatusForMediaType:AVMediaTypeAudio]) {
+            case AVAuthorizationStatusAuthorized:
+                return ERROR_NONE;
+            case AVAuthorizationStatusDenied:
+            case AVAuthorizationStatusRestricted:
+                return ERROR_NOT_ALLOWED;
+            case AVAuthorizationStatusNotDetermined: {
+                static std::atomic<bool> requested { false };
+                if (!requested.exchange(true)) {
+                    [AVCaptureDevice requestAccessForMediaType:AVMediaTypeAudio completionHandler:^(BOOL granted) {
+                        requested.store(false);
+                    }];
+                }
+                return ERROR_RESOURCE_BUSY;
+            }
+        }
+        return ERROR_NOT_ALLOWED;
+    }
+}

Devices/simulator/Source/drivers/sdl_bridge.cpp

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: Apache-2.0
+#include "sdl_bridge.h"
+#include "sdl_input.h"
+
+#include <tactility/error.h>
+
+#include <chrono>
+#include <condition_variable>
+#include <mutex>
+
+namespace {
+
+struct PresentJob {
+    Device* device;
+    void* internal;
+    int32_t x_start;
+    int32_t y_start;
+    int32_t x_end;
+    int32_t y_end;
+    const void* color_data;
+    error_t result;
+};
+
+std::mutex job_mutex;
+std::condition_variable job_ready_cv;
+std::condition_variable job_done_cv;
+bool job_pending = false;
+bool job_done = false;
+PresentJob pending_job;
+
+}
+
+error_t sdl_bridge_present(Device* device, void* internal, int32_t x_start, int32_t y_start, int32_t x_end, int32_t y_end, const void* color_data) {
+    std::unique_lock<std::mutex> lock(job_mutex);
+
+    pending_job = { device, internal, x_start, y_start, x_end, y_end, color_data, ERROR_NONE };
+    job_pending = true;
+    job_done = false;
+    job_ready_cv.notify_one();
+
+    job_done_cv.wait(lock, [] { return job_done; });
+    return pending_job.result;
+}
+
+void sdl_bridge_run_main_loop() {
+    while (true) {
+        sdl_input_pump();
+
+        std::unique_lock<std::mutex> lock(job_mutex);
+        if (job_ready_cv.wait_for(lock, std::chrono::milliseconds(1), [] { return job_pending; })) {
+            PresentJob job = pending_job;
+            lock.unlock();
+
+            job.result = sdl_display_execute_draw_bitmap(job.device, job.internal, job.x_start, job.y_start, job.x_end, job.y_end, job.color_data);
+
+            lock.lock();
+            pending_job.result = job.result;
+            job_pending = false;
+            job_done = true;
+            lock.unlock();
+            job_done_cv.notify_one();
+        }
+    }
+}

Devices/simulator/Source/drivers/sdl_bridge.h

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+
+#include <tactility/error.h>
+
+#include <stdint.h>
+
+struct Device;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Runs forever, pumping SDL input and executing display present jobs submitted via
+ * sdl_bridge_present(). Must be called exactly once, from the real OS main thread: macOS requires
+ * SDL/Cocoa window creation, event pumping and rendering to happen there, but FreeRTOS tasks
+ * (including the lvgl task that owns display flush and indev polling) run on separate pthreads
+ * spawned by the FreeRTOS POSIX port, not on that thread.
+ */
+void sdl_bridge_run_main_loop(void);
+
+/**
+ * @brief Hands a display flush off to the main thread and blocks until it has finished copying
+ * the pixel data out (see sdl_display_execute_draw_bitmap() in sdl_display.cpp). Called from the
+ * lvgl task. Must block: the caller's pixel buffer is single-buffered and gets reused as soon as
+ * this returns.
+ */
+error_t sdl_bridge_present(struct Device* device, void* internal, int32_t x_start, int32_t y_start, int32_t x_end, int32_t y_end, const void* color_data);
+
+/**
+ * @brief Implemented in sdl_display.cpp: the actual SDL work behind a display flush (lazy window
+ * init on first call, SDL_UpdateTexture, present). Only ever called from sdl_bridge_run_main_loop()
+ * on the main thread.
+ */
+error_t sdl_display_execute_draw_bitmap(struct Device* device, void* internal, int32_t x_start, int32_t y_start, int32_t x_end, int32_t y_end, const void* color_data);
+
+#ifdef __cplusplus
+}
+#endif

Devices/simulator/Source/drivers/sdl_display.cpp

@@ -1,5 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 #include "sdl_display.h"
+#include "sdl_bridge.h"
 
 #include <tactility/device.h>
 #include <tactility/driver.h>
@@ -141,8 +142,10 @@ static bool sdl_display_lazy_init(Device* device, SdlDisplayInternal* internal)
     return true;
 }
 
-static error_t sdl_display_draw_bitmap(Device* device, int32_t x_start, int32_t y_start, int32_t x_end, int32_t y_end, const void* color_data) {
-    auto* internal = static_cast<SdlDisplayInternal*>(device_get_driver_data(device));
+// Only ever called from sdl_bridge_run_main_loop() on the real main thread - required for
+// SDL/Cocoa window creation and rendering on macOS.
+error_t sdl_display_execute_draw_bitmap(Device* device, void* internal_ptr, int32_t x_start, int32_t y_start, int32_t x_end, int32_t y_end, const void* color_data) {
+    auto* internal = static_cast<SdlDisplayInternal*>(internal_ptr);
 
     if (internal->init_failed) {
         return ERROR_RESOURCE;
@@ -166,6 +169,16 @@ static error_t sdl_display_draw_bitmap(Device* device, int32_t x_start, int32_t
     return ERROR_NONE;
 }
 
+static error_t sdl_display_draw_bitmap(Device* device, int32_t x_start, int32_t y_start, int32_t x_end, int32_t y_end, const void* color_data) {
+    auto* internal = static_cast<SdlDisplayInternal*>(device_get_driver_data(device));
+
+    if (internal->init_failed) {
+        return ERROR_RESOURCE;
+    }
+
+    return sdl_bridge_present(device, internal, x_start, y_start, x_end, y_end, color_data);
+}
+
 static enum DisplayColorFormat sdl_display_get_color_format(Device*) {
     return DISPLAY_COLOR_FORMAT_RGB565;
 }

Devices/simulator/Source/drivers/sdl_input.cpp

@@ -7,13 +7,48 @@
 #include <SDL2/SDL.h>
 
 #include <cstdlib>
+#include <mutex>
 
 namespace {
 
 constexpr size_t KEY_QUEUE_CAPACITY = 32;
 
+// Written by sdl_input_pump() on the real main thread, read by sdl_input_get_pointer_state()/
+// sdl_input_pop_key()/sdl_input_has_queued_key() on the lvgl task.
+std::mutex state_mutex;
+
 SdlPointerState pointer_state = { 0, 0, false };
 
+} // namespace
+
+// Web touch-injection override (headless sim viewer). Guarded by tick count so
+// a press auto-releases even if the viewer never sends the release event.
+// File-scope (not anonymous namespace): the extern "C" setters below must be
+// visible to the linker for WebServerService's touch endpoint.
+bool touch_override_active = false;
+SdlPointerState touch_override = { 0, 0, false };
+uint32_t touch_override_until_tick = 0;
+#define SIM_TOUCH_HOLD_MS 1500
+
+extern "C" void sdl_input_set_touch_override(int32_t x, int32_t y, bool pressed) {
+    std::lock_guard<std::mutex> lock(state_mutex);
+    touch_override.x = x;
+    touch_override.y = y;
+    touch_override.pressed = pressed;
+    touch_override_active = pressed;
+    if (pressed) {
+        touch_override_until_tick = SDL_GetTicks() + SIM_TOUCH_HOLD_MS;
+    }
+}
+
+extern "C" void sdl_input_clear_touch_override(void) {
+    std::lock_guard<std::mutex> lock(state_mutex);
+    touch_override_active = false;
+    touch_override.pressed = false;
+}
+
+namespace {
+
 uint32_t key_queue[KEY_QUEUE_CAPACITY];
 size_t key_queue_head = 0;
 size_t key_queue_count = 0;
@@ -70,65 +105,92 @@ uint32_t keycode_to_key(SDL_Keycode sdl_key, bool shift) {
     }
 }
 
-}
+} // namespace
 
 void sdl_input_pump() {
-    if (!text_input_started) {
-        SDL_StartTextInput();
-        text_input_started = true;
+    // exit() must run with state_mutex unlocked: it never returns, so a lock_guard held across it
+    // would never release the mutex, hanging any other thread that later calls into this file's
+    // other functions (all of which lock state_mutex) while exit() tears the process down.
+    bool quit_requested = false;
+
+    {
+        std::lock_guard<std::mutex> lock(state_mutex);
+
+        if (!text_input_started) {
+            SDL_StartTextInput();
+            text_input_started = true;
+        }
+
+        SDL_Event event;
+        while (SDL_PollEvent(&event)) {
+            switch (event.type) {
+                case SDL_MOUSEMOTION:
+                    set_pointer_position(event.motion.x, event.motion.y);
+                    break;
+                case SDL_MOUSEBUTTONDOWN:
+                    if (event.button.button == SDL_BUTTON_LEFT) {
+                        // event.button.x/y can be stale immediately after a window resize (an
+                        // SDL/X11 event-queue quirk - confirmed by comparing against a live
+                        // SDL_GetWindowSize() at the same instant). SDL_GetMouseState() queries the
+                        // OS for the current pointer position directly, sidestepping that entirely.
+                        int live_x, live_y;
+                        SDL_GetMouseState(&live_x, &live_y);
+                        set_pointer_position(live_x, live_y);
+                        pointer_state.pressed = true;
+                    }
+                    break;
+                case SDL_MOUSEBUTTONUP:
+                    if (event.button.button == SDL_BUTTON_LEFT) {
+                        pointer_state.pressed = false;
+                    }
+                    break;
+                case SDL_KEYDOWN:
+                    push_key(keycode_to_key(event.key.keysym.sym, (event.key.keysym.mod & KMOD_SHIFT) != 0));
+                    break;
+                case SDL_TEXTINPUT:
+                    // ASCII only (first byte of event.text.text) - sufficient for a simulator keyboard.
+                    push_key(static_cast<uint8_t>(event.text.text[0]));
+                    break;
+                case SDL_WINDOWEVENT:
+                    // Resizing doesn't change what LVGL last rendered, only how large it should
+                    // appear - re-present the existing frame at the new scale immediately, rather
+                    // than leaving stale-looking content on screen until the next LVGL-driven flush.
+                    if (event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED) {
+                        sdl_display_present_now();
+                    }
+                    break;
+                case SDL_QUIT:
+                    quit_requested = true;
+                    break;
+                default:
+                    break;
+            }
+        }
     }
 
-    SDL_Event event;
-    while (SDL_PollEvent(&event)) {
-        switch (event.type) {
-            case SDL_MOUSEMOTION:
-                set_pointer_position(event.motion.x, event.motion.y);
-                break;
-            case SDL_MOUSEBUTTONDOWN:
-                if (event.button.button == SDL_BUTTON_LEFT) {
-                    // event.button.x/y can be stale immediately after a window resize (an
-                    // SDL/X11 event-queue quirk - confirmed by comparing against a live
-                    // SDL_GetWindowSize() at the same instant). SDL_GetMouseState() queries the
-                    // OS for the current pointer position directly, sidestepping that entirely.
-                    int live_x, live_y;
-                    SDL_GetMouseState(&live_x, &live_y);
-                    set_pointer_position(live_x, live_y);
-                    pointer_state.pressed = true;
-                }
-                break;
-            case SDL_MOUSEBUTTONUP:
-                if (event.button.button == SDL_BUTTON_LEFT) {
-                    pointer_state.pressed = false;
-                }
-                break;
-            case SDL_KEYDOWN:
-                push_key(keycode_to_key(event.key.keysym.sym, (event.key.keysym.mod & KMOD_SHIFT) != 0));
-                break;
-            case SDL_TEXTINPUT:
-                // ASCII only (first byte of event.text.text) - sufficient for a simulator keyboard.
-                push_key(static_cast<uint8_t>(event.text.text[0]));
-                break;
-            case SDL_WINDOWEVENT:
-                // Resizing doesn't change what LVGL last rendered, only how large it should
-                // appear - re-present the existing frame at the new scale immediately, rather
-                // than leaving stale-looking content on screen until the next LVGL-driven flush.
-                if (event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED) {
-                    sdl_display_present_now();
-                }
-                break;
-            case SDL_QUIT:
-                exit(0);
-            default:
-                break;
-        }
+    if (quit_requested) {
+        exit(0);
     }
 }
 
 void sdl_input_get_pointer_state(SdlPointerState* out_state) {
+    std::lock_guard<std::mutex> lock(state_mutex);
+    if (touch_override_active) {
+        // Auto-release: viewer sends press only; LVGL needs press then release
+        // to register a click. Hold long enough for several indev polls.
+        if ((int32_t)(SDL_GetTicks() - touch_override_until_tick) >= 0) {
+            touch_override_active = false;
+            touch_override.pressed = false;
+        } else {
+            *out_state = touch_override;
+            return;
+        }
+    }
     *out_state = pointer_state;
 }
 
 bool sdl_input_pop_key(uint32_t* out_key) {
+    std::lock_guard<std::mutex> lock(state_mutex);
     if (key_queue_count == 0) {
         return false;
     }
@@ -139,5 +201,6 @@ bool sdl_input_pop_key(uint32_t* out_key) {
 }
 
 bool sdl_input_has_queued_key() {
+    std::lock_guard<std::mutex> lock(state_mutex);
     return key_queue_count > 0;
 }

Devices/simulator/Source/drivers/sdl_input.h

@@ -19,9 +19,9 @@ struct SdlPointerState {
 
 /**
  * @brief Drains all pending SDL events exactly once, updating the pointer state and key queue
- * below. Safe to call from both the sdl-pointer and sdl-keyboard drivers' polling functions:
- * SDL_PollEvent() drains a single global queue, so whichever driver is polled first on a given
- * LVGL indev tick pumps events for both.
+ * below. Must be called only from the real OS main thread (sdl_bridge_run_main_loop()): SDL
+ * requires event pumping to happen there on macOS. The getters below are safe to call from a
+ * different thread (the lvgl task, via sdl-pointer/sdl-keyboard's polling functions).
  */
 void sdl_input_pump(void);
 
@@ -42,6 +42,16 @@ bool sdl_input_pop_key(uint32_t* out_key);
  */
 bool sdl_input_has_queued_key(void);
 
+/**
+ * @brief Web-injected touch override (for headless sim viewer without SDL window).
+ * When active, sdl_pointer_get_touched_points() reports this state instead of
+ * the SDL mouse state. Coordinates are in LVGL logical pixels (e.g. 640x480).
+ * Pass pressed=false to release. Auto-releases after SIM_TOUCH_HOLD_MS unless
+ * refreshed (tap = press, wait, release handled by the web viewer).
+ */
+void sdl_input_set_touch_override(int32_t x, int32_t y, bool pressed);
+void sdl_input_clear_touch_override(void);
+
 #ifdef __cplusplus
 }
 #endif

Devices/simulator/Source/drivers/sdl_keyboard.cpp

@@ -16,8 +16,6 @@ static error_t stop(Device*) { return ERROR_NONE; }
 // region KeyboardApi
 
 static error_t sdl_keyboard_read_key(Device*, KeyboardKeyData* data) {
-    sdl_input_pump();
-
     uint32_t key = 0;
     if (sdl_input_pop_key(&key)) {
         data->key = key;

Devices/simulator/Source/drivers/sdl_pointer.cpp

@@ -16,7 +16,6 @@ static error_t stop(Device*) { return ERROR_NONE; }
 // region PointerApi
 
 static error_t sdl_pointer_read_data(Device*, TickType_t) {
-    sdl_input_pump();
     return ERROR_NONE;
 }
 

Devices/simulator/Source/module.cpp

@@ -1,4 +1,5 @@
 #include "drivers/sdl_display.h"
+#include "drivers/sdl_audio.h"
 
 #include <tactility/device.h>
 #include <tactility/device_listener.h>
@@ -16,11 +17,13 @@ extern "C" {
 extern Driver sdl_display_driver;
 extern Driver sdl_pointer_driver;
 extern Driver sdl_keyboard_driver;
+extern Driver sdl_audio_driver;
 
 static Driver* const simulator_drivers[] = {
     &sdl_display_driver,
     &sdl_pointer_driver,
     &sdl_keyboard_driver,
+    &sdl_audio_driver,
     nullptr
 };
 
@@ -29,10 +32,35 @@ static Driver* const simulator_drivers[] = {
 // These devices have no real bus to attach to (SDL has no notion of one), but every non-root
 // device is still expected to have a parent (see Device::parent) - they're parented to root once
 // it's available below.
-static const SdlDisplayConfig sdl_display_config = { 640, 480 };
+// Display resolution is overridable at runtime via SIM_DISPLAY_W/H env vars
+// so the sim can match real hardware (e.g. ES3C35P 3.5" = 320x480 portrait,
+// ES3C28P 2.8" = 320x240 landscape). Defaults to 640x480.
+static uint16_t sim_display_width(void) {
+    const char* w = getenv("SIM_DISPLAY_W");
+    if (w != nullptr) {
+        long v = atol(w);
+        if (v >= 120 && v <= 2048) return (uint16_t)v;
+    }
+    return 480;
+}
+
+static uint16_t sim_display_height(void) {
+    const char* h = getenv("SIM_DISPLAY_H");
+    if (h != nullptr) {
+        long v = atol(h);
+        if (v >= 120 && v <= 2048) return (uint16_t)v;
+    }
+    return 320;
+}
+
+static SdlDisplayConfig sdl_display_config = { 480, 320 };
 static Device sdl_display_device {};
 static Device sdl_pointer_device {};
 static Device sdl_keyboard_device {};
+static Device sdl_speaker_device {};
+static Device sdl_microphone_device {};
+static const SdlAudioConfig sdl_speaker_config { AUDIO_CODEC_DIR_OUTPUT };
+static const SdlAudioConfig sdl_microphone_config { AUDIO_CODEC_DIR_INPUT };
 
 static bool construct_add_start(Device* device, Device* parent, const char* name, const void* config, const char* compatible) {
     device->address = 0;
@@ -81,9 +109,15 @@ static void on_root_started(Device* device, DeviceEvent event, void* context) {
         return;
     }
 
+    sdl_display_config.horizontal_resolution = sim_display_width();
+    sdl_display_config.vertical_resolution = sim_display_height();
+    LOG_I(TAG, "Sim display %dx%d (SIM_DISPLAY_W/H override, default 480x320 landscape)",
+        sdl_display_config.horizontal_resolution, sdl_display_config.vertical_resolution);
     construct_add_start(&sdl_display_device, device, "display0", &sdl_display_config, "tactility,sdl-display");
     construct_add_start(&sdl_pointer_device, device, "pointer0", nullptr, "tactility,sdl-pointer");
     construct_add_start(&sdl_keyboard_device, device, "keyboard0", nullptr, "tactility,sdl-keyboard");
+    construct_add_start(&sdl_speaker_device, device, "speaker0", &sdl_speaker_config, "tactility,sdl-audio");
+    construct_add_start(&sdl_microphone_device, device, "microphone0", &sdl_microphone_config, "tactility,sdl-audio");
 }
 
 extern "C" {

Devices/simulator/devicetree.yaml

@@ -1,3 +1,4 @@
 dependencies:
   - Platforms/platform-posix
+  - Drivers/audio-stream-module
 dts: simulator.dts

Devices/simulator/macos-info.plist

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>CFBundleIdentifier</key>
+    <string>org.tactilityproject.simulator</string>
+    <key>CFBundleName</key>
+    <string>Tactility</string>
+    <key>NSMicrophoneUsageDescription</key>
+    <string>Tactility uses the microphone when a simulator app records audio.</string>
+</dict>
+</plist>

Devices/simulator/tests/CMakeLists.txt

@@ -0,0 +1,14 @@
+add_executable(SimulatorAudioTests EXCLUDE_FROM_ALL
+    audio.cpp
+    ../Source/drivers/sdl_audio.cpp
+)
+target_include_directories(SimulatorAudioTests PRIVATE ${DOCTESTINC} ../Source/drivers)
+target_link_libraries(SimulatorAudioTests PRIVATE TactilityKernel platform-posix audio-stream-module SDL2-static)
+if (APPLE)
+    target_sources(SimulatorAudioTests PRIVATE ../Source/drivers/sdl_audio_permission.mm)
+    target_link_libraries(SimulatorAudioTests PRIVATE "-framework AVFoundation" "-framework Foundation")
+endif ()
+add_test(NAME SimulatorAudioTests COMMAND SimulatorAudioTests)
+set_tests_properties(SimulatorAudioTests PROPERTIES TIMEOUT 30 ENVIRONMENT "SDL_AUDIODRIVER=dummy;SIM_AUDIO_INPUT=;SIM_AUDIO_OUTPUT=")
+add_test(NAME SimulatorAudioPcmTests COMMAND SimulatorAudioTests --no-skip "--test-case=disk PCM*")
+set_tests_properties(SimulatorAudioPcmTests PROPERTIES TIMEOUT 30 ENVIRONMENT "SDL_AUDIODRIVER=disk;SIM_AUDIO_INPUT=;SIM_AUDIO_OUTPUT=")

Devices/simulator/tests/audio.cpp

@@ -0,0 +1,301 @@
+// SPDX-License-Identifier: Apache-2.0
+#define DOCTEST_CONFIG_IMPLEMENT
+#include "doctest.h"
+#include "sdl_audio.h"
+#include "sdl_audio_buffer.h"
+
+#include <tactility/device.h>
+#include <tactility/driver.h>
+#include <tactility/drivers/audio_stream.h>
+#include <tactility/freertos/task.h>
+#include <tactility/kernel_init.h>
+
+#include <SDL2/SDL.h>
+#include <algorithm>
+#include <cmath>
+#include <cstdlib>
+#include <cstdio>
+#include <fstream>
+#include <unistd.h>
+#include <vector>
+
+extern Driver sdl_audio_driver;
+extern "C" {
+extern Module platform_posix_module;
+extern Module audio_stream_module;
+extern Device audio_stream_device;
+static Driver* const drivers[] = { &sdl_audio_driver, nullptr };
+Module simulator_module = { .name = "simulator-audio-test", .drivers = drivers };
+}
+
+static const SdlAudioConfig output_config { AUDIO_CODEC_DIR_OUTPUT };
+static const SdlAudioConfig input_config { AUDIO_CODEC_DIR_INPUT };
+static Device speaker { .name = "speaker-test", .config = &output_config };
+static Device microphone { .name = "microphone-test", .config = &input_config };
+
+struct Stream {
+    AudioStreamHandle handle = nullptr;
+    ~Stream() { if (handle != nullptr) audio_stream_close(handle); }
+};
+
+TEST_CASE("bounded PCM buffer preserves data across wrap and overflow") {
+    SdlAudioBuffer buffer;
+    std::vector<int16_t> input(20000);
+    for (size_t i = 0; i < input.size(); ++i) input[i] = static_cast<int16_t>(i);
+    std::vector<int16_t> output(20000, -1);
+    CHECK(buffer.read(output.data(), output.size()) == 0);
+    REQUIRE(buffer.write(input.data(), input.size()) == 16384);
+    CHECK(buffer.write(input.data(), 2) == 0);
+    REQUIRE(buffer.read(output.data(), 10000) == 10000);
+    CHECK(std::equal(output.begin(), output.begin() + 10000, input.begin()));
+    REQUIRE(buffer.write(input.data(), 10000) == 10000);
+    REQUIRE(buffer.read(output.data(), output.size()) == 16384);
+    CHECK(std::equal(output.begin(), output.begin() + 6384, input.begin() + 10000));
+    CHECK(std::equal(output.begin() + 6384, output.begin() + 16384, input.begin()));
+    CHECK(buffer.empty());
+}
+
+TEST_CASE("simulator streams support independent full duplex and common PCM rates") {
+    for (uint32_t rate : { 16000u, 44100u, 48000u }) {
+        CAPTURE(rate);
+        const AudioStreamConfig config { rate, 16, 1 };
+        Stream input;
+        Stream output;
+        REQUIRE(audio_stream_open_input(&audio_stream_device, &config, &input.handle) == ERROR_NONE);
+        REQUIRE(audio_stream_open_output(&audio_stream_device, &config, &output.handle) == ERROR_NONE);
+        AudioStreamHandle duplicate = nullptr;
+        CHECK(audio_stream_open_output(&audio_stream_device, &config, &duplicate) == ERROR_INVALID_STATE);
+        std::vector<int16_t> samples(rate / 20, 1234);
+        size_t count = 0;
+        REQUIRE(audio_stream_write(output.handle, samples.data(), samples.size() * 2, &count, pdMS_TO_TICKS(1000)) == ERROR_NONE);
+        CHECK(count == samples.size() * 2);
+        REQUIRE(audio_stream_read(input.handle, samples.data(), samples.size() * 2, &count, pdMS_TO_TICKS(1000)) == ERROR_NONE);
+        CHECK(count == samples.size() * 2);
+        CHECK(std::all_of(samples.begin(), samples.end(), [](int16_t sample) { return sample == 0; }));
+        REQUIRE(audio_stream_close(output.handle) == ERROR_NONE);
+        output.handle = nullptr;
+        // Closing the speaker must not stop the microphone.
+        REQUIRE(audio_stream_read(input.handle, samples.data(), samples.size() * 2, &count, pdMS_TO_TICKS(1000)) == ERROR_NONE);
+    }
+}
+
+TEST_CASE("simulator audio controls persist across opens and disabling closes output") {
+    auto* device = &audio_stream_device;
+    REQUIRE(audio_stream_set_volume(device, AUDIO_CODEC_DIR_OUTPUT, 25.0f) == ERROR_NONE);
+    REQUIRE(audio_stream_set_mute(device, AUDIO_CODEC_DIR_OUTPUT, true) == ERROR_NONE);
+    const AudioStreamConfig config { 48000, 16, 2 };
+    Stream output;
+    REQUIRE(audio_stream_open_output(device, &config, &output.handle) == ERROR_NONE);
+    float volume = 0;
+    bool muted = false;
+    REQUIRE(audio_codec_get_volume(&speaker, AUDIO_CODEC_DIR_OUTPUT, &volume) == ERROR_NONE);
+    REQUIRE(audio_codec_get_mute(&speaker, AUDIO_CODEC_DIR_OUTPUT, &muted) == ERROR_NONE);
+    CHECK(volume == 25.0f);
+    CHECK(muted);
+    REQUIRE(audio_stream_set_enabled(device, AUDIO_CODEC_DIR_OUTPUT, false) == ERROR_NONE);
+    output.handle = nullptr; // set_enabled closes and owns destruction of the handle
+    CHECK(audio_stream_open_output(device, &config, &output.handle) == ERROR_NOT_ALLOWED);
+    REQUIRE(audio_stream_set_enabled(device, AUDIO_CODEC_DIR_OUTPUT, true) == ERROR_NONE);
+    REQUIRE(audio_stream_set_mute(device, AUDIO_CODEC_DIR_OUTPUT, false) == ERROR_NONE);
+    REQUIRE(audio_stream_open_output(device, &config, &output.handle) == ERROR_NONE);
+}
+
+TEST_CASE("bounded playback reports partial progress on a nonblocking timeout") {
+    const AudioStreamConfig config { 48000, 16, 2 };
+    Stream output;
+    REQUIRE(audio_stream_open_output(&audio_stream_device, &config, &output.handle) == ERROR_NONE);
+    std::vector<int16_t> samples(48000 * 2, 0);
+    size_t count = 999;
+    CHECK(audio_stream_write(output.handle, samples.data(), samples.size() * 2, &count, 0) == ERROR_TIMEOUT);
+    CHECK(count > 0);
+    CHECK(count < samples.size() * 2);
+    CHECK(count % 4 == 0);
+}
+
+TEST_CASE("converted streams report partial progress on timeout") {
+    const AudioStreamConfig config { 16000, 16, 1 };
+    Stream output;
+    Stream input;
+    REQUIRE(audio_stream_open_output(&audio_stream_device, &config, &output.handle) == ERROR_NONE);
+    REQUIRE(audio_stream_open_input(&audio_stream_device, &config, &input.handle) == ERROR_NONE);
+    std::vector<int16_t> samples(16000, 0);
+    size_t count = 999;
+    CHECK(audio_stream_write(output.handle, samples.data(), samples.size() * 2, &count, 0) == ERROR_TIMEOUT);
+    CHECK(count > 0);
+    CHECK(count < samples.size() * 2);
+    CHECK(count % 2 == 0);
+    vTaskDelay(pdMS_TO_TICKS(30)); // allow dummy capture to produce some samples
+    count = 999;
+    CHECK(audio_stream_read(input.handle, samples.data(), samples.size() * 2, &count, 0) == ERROR_TIMEOUT);
+    CHECK(count > 0);
+    CHECK(count < samples.size() * 2);
+    CHECK(count % 2 == 0);
+}
+
+TEST_CASE("missing selected microphone does not prevent speaker playback") {
+    REQUIRE(SDL_setenv("SIM_AUDIO_INPUT", "tactility-nonexistent-microphone", 1) == 0);
+    AudioCodecDirection capability;
+    CHECK(audio_codec_get_capabilities(&microphone, &capability) == ERROR_NOT_SUPPORTED);
+    const AudioCodecStreamConfig config { 48000, 16, 1, AUDIO_CODEC_DIR_INPUT };
+    CHECK(audio_codec_open(&microphone, &config) == ERROR_NOT_SUPPORTED);
+    CHECK(audio_codec_get_capabilities(&speaker, &capability) == ERROR_NONE);
+    CHECK(capability == AUDIO_CODEC_DIR_OUTPUT);
+    REQUIRE(SDL_setenv("SIM_AUDIO_INPUT", "", 1) == 0);
+}
+
+TEST_CASE("unsupported sample widths fail without breaking a later open") {
+    AudioStreamConfig config { 16000, 24, 1 };
+    Stream output;
+    CHECK(audio_stream_open_output(&audio_stream_device, &config, &output.handle) != ERROR_NONE);
+    CHECK(output.handle == nullptr);
+    config.bits_per_sample = 16;
+    REQUIRE(audio_stream_open_output(&audio_stream_device, &config, &output.handle) == ERROR_NONE);
+}
+
+TEST_CASE("zero sample rate is rejected before conversion") {
+    const AudioStreamConfig config { 0, 16, 1 };
+    Stream output;
+    CHECK(audio_stream_open_output(&audio_stream_device, &config, &output.handle) == ERROR_INVALID_ARGUMENT);
+}
+
+TEST_CASE("disabling while a codec is opening cancels the pending stream") {
+    const auto* original_api = static_cast<const AudioCodecApi*>(sdl_audio_driver.api);
+    static const AudioCodecApi* wrapped_api;
+    wrapped_api = original_api;
+    AudioCodecApi delayed_api = *original_api;
+    delayed_api.open = [](Device* device, const AudioCodecStreamConfig* config) {
+        vTaskDelay(pdMS_TO_TICKS(50)); // models waiting for microphone permission
+        return wrapped_api->open(device, config);
+    };
+    sdl_audio_driver.api = &delayed_api;
+    struct RestoreApi {
+        const AudioCodecApi* api;
+        ~RestoreApi() { sdl_audio_driver.api = api; }
+    } restore { original_api };
+    REQUIRE(xTaskCreate([](void*) {
+        vTaskDelay(pdMS_TO_TICKS(5));
+        audio_stream_set_enabled(&audio_stream_device, AUDIO_CODEC_DIR_OUTPUT, false);
+        // Re-enabling does not resurrect the cancelled attempt.
+        audio_stream_set_enabled(&audio_stream_device, AUDIO_CODEC_DIR_OUTPUT, true);
+        vTaskDelete(nullptr);
+    }, "disable-audio", 8192, nullptr, 1, nullptr) == pdPASS);
+    const AudioStreamConfig config { 48000, 16, 2 };
+    Stream output;
+    CHECK(audio_stream_open_output(&audio_stream_device, &config, &output.handle) == ERROR_NOT_ALLOWED);
+    CHECK(output.handle == nullptr);
+    sdl_audio_driver.api = original_api;
+    REQUIRE(audio_stream_open_output(&audio_stream_device, &config, &output.handle) == ERROR_NONE);
+}
+
+TEST_CASE("hardware output smoke test" * doctest::skip()) {
+    // Explicit opt-in only: SDL_AUDIODRIVER=coreaudio ... --no-skip --test-case='hardware output smoke test'
+    const AudioStreamConfig config { 48000, 16, 2 };
+    Stream output;
+    REQUIRE(audio_stream_set_volume(&audio_stream_device, AUDIO_CODEC_DIR_OUTPUT, 20) == ERROR_NONE);
+    REQUIRE(audio_stream_open_output(&audio_stream_device, &config, &output.handle) == ERROR_NONE);
+    std::vector<int16_t> samples(48000); // half a second, stereo, quiet 440 Hz tone
+    for (size_t frame = 0; frame < samples.size() / 2; ++frame) {
+        samples[frame * 2] = samples[frame * 2 + 1] = static_cast<int16_t>(3000 * std::sin(frame * 440.0 * 6.283185307 / 48000));
+    }
+    size_t count = 0;
+    REQUIRE(audio_stream_write(output.handle, samples.data(), samples.size() * 2, &count, pdMS_TO_TICKS(2000)) == ERROR_NONE);
+    CHECK(count == samples.size() * 2);
+}
+
+TEST_CASE("disk PCM capture and playback apply gain and mute" * doctest::skip()) {
+    REQUIRE(std::strcmp(SDL_GetCurrentAudioDriver(), "disk") == 0);
+    auto* device = &audio_stream_device;
+    const AudioStreamConfig config { 48000, 16, 1 };
+    Stream input;
+    Stream output;
+    REQUIRE(audio_stream_set_volume(device, AUDIO_CODEC_DIR_INPUT, 50) == ERROR_NONE);
+    REQUIRE(audio_stream_set_volume(device, AUDIO_CODEC_DIR_OUTPUT, 25) == ERROR_NONE);
+    REQUIRE(audio_stream_open_input(device, &config, &input.handle) == ERROR_NONE);
+    REQUIRE(audio_stream_open_output(device, &config, &output.handle) == ERROR_NONE);
+    std::vector<int16_t> samples(960, -1);
+    size_t count = 0;
+    REQUIRE(audio_stream_read(input.handle, samples.data(), samples.size() * 2, &count, pdMS_TO_TICKS(1000)) == ERROR_NONE);
+    CHECK(count == samples.size() * 2);
+    // Fixture contains 10000; microphone gain is 50%.
+    CHECK(std::all_of(samples.begin(), samples.end(), [](int16_t sample) { return sample == 5000; }));
+    REQUIRE(audio_stream_write(output.handle, samples.data(), samples.size() * 2, &count, pdMS_TO_TICKS(1000)) == ERROR_NONE);
+    REQUIRE(audio_stream_close(output.handle) == ERROR_NONE);
+    output.handle = nullptr;
+    {
+        std::ifstream file(std::getenv("SDL_DISKAUDIOFILE"), std::ios::binary);
+        REQUIRE(file.good());
+        size_t nonzero = 0;
+        int16_t sample;
+        while (file.read(reinterpret_cast<char*>(&sample), sizeof(sample))) {
+            CHECK((sample == 0 || sample == 1250)); // 25% output volume
+            if (sample != 0) nonzero++;
+        }
+        CHECK(nonzero == samples.size() * 2); // mono was duplicated to stereo
+    }
+    REQUIRE(audio_stream_set_mute(device, AUDIO_CODEC_DIR_INPUT, true) == ERROR_NONE);
+    REQUIRE(audio_stream_read(input.handle, samples.data(), samples.size() * 2, &count, pdMS_TO_TICKS(1000)) == ERROR_NONE);
+    CHECK(std::all_of(samples.begin(), samples.end(), [](int16_t sample) { return sample == 0; }));
+    REQUIRE(audio_stream_set_mute(device, AUDIO_CODEC_DIR_OUTPUT, true) == ERROR_NONE);
+    REQUIRE(audio_stream_open_output(device, &config, &output.handle) == ERROR_NONE);
+    std::fill(samples.begin(), samples.end(), 5000);
+    REQUIRE(audio_stream_write(output.handle, samples.data(), samples.size() * 2, &count, pdMS_TO_TICKS(1000)) == ERROR_NONE);
+    REQUIRE(audio_stream_close(output.handle) == ERROR_NONE);
+    output.handle = nullptr;
+    std::ifstream file(std::getenv("SDL_DISKAUDIOFILE"), std::ios::binary);
+    REQUIRE(file.good());
+    size_t total = 0;
+    int16_t sample;
+    while (file.read(reinterpret_cast<char*>(&sample), sizeof(sample))) {
+        CHECK(sample == 0);
+        total++;
+    }
+    CHECK(total >= samples.size() * 2);
+}
+
+struct TestContext { int argc; char** argv; int result = 1; };
+
+static void run_tests(void* argument) {
+    auto* data = static_cast<TestContext*>(argument);
+    Module* modules[] = { &platform_posix_module, &simulator_module, &audio_stream_module, nullptr };
+    DtsDevice devices[] = { DTS_DEVICE_TERMINATOR };
+    if (kernel_init(modules, devices) == ERROR_NONE
+        && device_construct_add_start(&speaker, "tactility,sdl-audio") == ERROR_NONE
+        && device_construct_add_start(&microphone, "tactility,sdl-audio") == ERROR_NONE) {
+        doctest::Context context(data->argc, data->argv);
+        context.setOption("no-breaks", true);
+        data->result = context.run();
+        device_stop(&microphone);
+        device_stop(&speaker);
+    }
+    vTaskEndScheduler();
+    vTaskDelete(nullptr);
+}
+
+int main(int argc, char** argv) {
+    if (std::getenv("SDL_AUDIODRIVER") == nullptr) SDL_setenv("SDL_AUDIODRIVER", "dummy", 1);
+    char input_path[] = "sim-audio-input-XXXXXX";
+    char output_path[] = "sim-audio-output-XXXXXX";
+    const bool disk = std::strcmp(std::getenv("SDL_AUDIODRIVER"), "disk") == 0;
+    if (disk) {
+        const int input_fd = mkstemp(input_path);
+        const int output_fd = mkstemp(output_path);
+        if (input_fd < 0 || output_fd < 0) return 1;
+        FILE* file = fdopen(input_fd, "wb");
+        if (file == nullptr) return 1;
+        const std::vector<int16_t> fixture(48000, 10000);
+        const size_t written = std::fwrite(fixture.data(), sizeof(int16_t), fixture.size(), file);
+        std::fclose(file);
+        ::close(output_fd);
+        if (written != fixture.size()) return 1;
+        SDL_setenv("SDL_DISKAUDIOFILEIN", input_path, 1);
+        SDL_setenv("SDL_DISKAUDIOFILE", output_path, 1);
+    }
+    TestContext data { argc, argv };
+    if (xTaskCreate(run_tests, "audio-test", 32768, &data, 1, nullptr) != pdPASS) return 1;
+    vTaskStartScheduler();
+    if (disk) {
+        std::remove(input_path);
+        std::remove(output_path);
+    }
+    return data.result;
+}

Documentation/simulator-audio.md

@@ -0,0 +1,93 @@
+# Simulator audio
+
+The desktop simulator exposes an SDL speaker and microphone through Tactility's
+standard `audio_stream_*` API. On macOS, SDL uses CoreAudio. Audio Settings controls
+the simulator's input/output volume, mute, and enabled state; these controls do not
+change macOS's system volume.
+
+## Running on macOS
+
+Build the simulator in the usual host build environment (with `python`, `lark`,
+and `pyyaml` available, and without `ESP_IDF_VERSION`):
+
+```sh
+cmake -S . -B buildsim
+cmake --build buildsim --target Tactility -j 8
+```
+
+Create a fresh application bundle (the script deliberately refuses to overwrite
+an existing bundle):
+
+```sh
+sh Buildscripts/release-simulator-macos-app.sh buildsim release/Tactility-audio.app
+open release/Tactility-audio.app
+```
+
+Alternatively, run `../buildsim/Tactility/Tactility` with `Data/` as the working
+directory. Both the executable and the application bundle include a microphone
+usage description. macOS asks for microphone access on the first actual recording
+request, not at simulator startup. If denied, enable access in **System Settings
+→ Privacy & Security → Microphone** and relaunch. For command-line launches, macOS
+may attribute the permission to the terminal or launching application.
+
+A Mac mini needs an external input device, such as a USB mic or headset. Without
+an input device, speaker output still works and input is reported unavailable.
+Connect the input before launch for predictable discovery/UI behavior.
+
+## Selecting devices
+
+By default, each stream opens the system's default device. Startup logs list SDL's
+device names. Optional environment variables select an exact name:
+
+```sh
+SIM_AUDIO_OUTPUT="Mac mini Speakers" SIM_AUDIO_INPUT="USB Microphone" \
+  release/Tactility-audio.app/Contents/MacOS/Tactility
+```
+
+- `SIM_AUDIO_OUTPUT`: exact output name, or `none` to disable output.
+- `SIM_AUDIO_INPUT`: exact input name, or `none` to disable input.
+- Unset or empty values use the system default.
+
+Selection is applied when opening a stream. An already-open stream does not
+automatically switch when the system default changes; close/reopen it or relaunch.
+A missing selected device causes an open failure rather than silently selecting a
+different device. Permission/device errors are logged under `SdlAudio`.
+
+## Formats and behavior
+
+- Signed 16-bit PCM; the shared stream module converts app sample rates and channel
+  counts to 48 kHz mono capture / stereo playback. SDL handles host format conversion.
+- One input and one output stream can be open simultaneously.
+- Read/write from a worker task, never the LVGL thread.
+- Audio callbacks use bounded lock-free buffers, with silence on playback underrun
+  and dropped incoming frames on capture overflow.
+- Reads/writes report partial byte counts on timeout, including converted streams.
+- Closing output drains its bounded buffer for up to 250 ms. Closing input does not
+  affect output, and vice versa.
+- No audio mixing or acoustic echo cancellation is added by this backend. Use
+  headphones when testing simultaneous microphone capture and playback.
+
+## Verification
+
+```sh
+cmake --build buildsim --target SimulatorAudioTests -j 8
+ctest --test-dir buildsim/Tests -R SimulatorAudio --output-on-failure
+```
+
+These tests use SDL's dummy and disk backends without requiring microphone access.
+They cover full duplex, 16/44.1/48 kHz app formats, bounded buffering, partial
+timeouts, enable/disable, unavailable inputs, and sample-level input/output gain
+and mute. They also cover disabling audio while a slow codec open is pending,
+as can happen during a microphone permission prompt. Disk fixtures and output
+files are temporary and removed after the run.
+
+To explicitly play a quiet half-second 440 Hz tone through real Mac audio:
+
+```sh
+SDL_AUDIODRIVER=coreaudio SIM_AUDIO_OUTPUT= \
+  buildsim/Tests/simulator/SimulatorAudioTests \
+  --no-skip --test-case="hardware output smoke test"
+```
+
+Physical microphone capture, the first-use permission prompt, and live device
+unplugging require a separate manual check with an input device attached.

Drivers/audio-stream-module/source/audio_stream.cpp

@@ -113,6 +113,10 @@ struct AudioStreamHandleImpl : AudioStreamHandleData {
     SemaphoreHandle_t drain_semaphore = nullptr;
 };
 
+// A slow codec open (notably the macOS microphone permission prompt) reserves a
+// direction before a real handle exists. It must never be passed to close_stream().
+AudioStreamHandleImpl* const OPENING_STREAM = reinterpret_cast<AudioStreamHandleImpl*>(1);
+
 struct AudioStreamData {
     Device* input_codec = nullptr;
     Device* output_codec = nullptr;
@@ -130,6 +134,8 @@ struct AudioStreamData {
     bool output_muted = false;
     AudioStreamHandleImpl* open_input = nullptr;
     AudioStreamHandleImpl* open_output = nullptr;
+    bool input_open_cancelled = false;
+    bool output_open_cancelled = false;
     // Guards open_input/open_output and the closing/busy_count fields of any handle reachable
     // through them, so close (possibly forced by set_enabled) can't race with read/write.
     SemaphoreHandle_t mutex = nullptr;
@@ -261,7 +267,7 @@ error_t open_stream(Device* device, const struct AudioStreamConfig* config, Audi
         return ERROR_INVALID_ARGUMENT;
     }
 
-    if (config->channels == 0) {
+    if (config->channels == 0 || config->sample_rate == 0) {
         return ERROR_INVALID_ARGUMENT;
     }
 
@@ -291,7 +297,9 @@ error_t open_stream(Device* device, const struct AudioStreamConfig* config, Audi
 
     // Reserve the slot with a placeholder so concurrent opens can't race past the check
     // above while we do the (potentially slow) codec open below outside the lock.
-    auto* reservation = reinterpret_cast<AudioStreamHandleImpl*>(1);
+    auto* reservation = OPENING_STREAM;
+    bool* open_cancelled = is_input ? &data->input_open_cancelled : &data->output_open_cancelled;
+    *open_cancelled = false;
     *slot = reservation;
     xSemaphoreGive(data->mutex);
 
@@ -361,6 +369,18 @@ error_t open_stream(Device* device, const struct AudioStreamConfig* config, Audi
     }
 
     xSemaphoreTake(data->mutex, portMAX_DELAY);
+    if (*open_cancelled) {
+        // Keep the reservation until the codec is closed, so re-enabling cannot
+        // open a second stream while this cancelled open is still cleaning up.
+        xSemaphoreGive(data->mutex);
+        vSemaphoreDelete(handle->drain_semaphore);
+        delete handle;
+        audio_codec_close(codec);
+        xSemaphoreTake(data->mutex, portMAX_DELAY);
+        *slot = nullptr;
+        xSemaphoreGive(data->mutex);
+        return ERROR_NOT_ALLOWED;
+    }
     *slot = handle;
     xSemaphoreGive(data->mutex);
 
@@ -377,6 +397,7 @@ error_t open_output(Device* device, const struct AudioStreamConfig* config, Audi
 }
 
 error_t read_stream(AudioStreamHandle handle_base, void* out_data, size_t data_size, size_t* bytes_read, TickType_t timeout) {
+    if (bytes_read != nullptr) *bytes_read = 0;
     auto* handle = static_cast<AudioStreamHandleImpl*>(handle_base);
     if (handle->direction != AUDIO_CODEC_DIR_INPUT || handle->bytes_per_frame == 0) {
         return ERROR_INVALID_STATE;
@@ -419,7 +440,7 @@ error_t read_stream(AudioStreamHandle handle_base, void* out_data, size_t data_s
 
         size_t codec_bytes_read = 0;
         result = audio_codec_read(data->input_codec, handle->codec_buffer.data(), codec_bytes_needed, &codec_bytes_read, timeout);
-        if (result == ERROR_NONE) {
+        if (codec_bytes_read > 0) {
             size_t codec_frames_read = codec_bytes_read / handle->codec_bytes_per_frame;
             const int16_t* rate_input = reinterpret_cast<const int16_t*>(handle->codec_buffer.data());
             uint8_t rate_input_channels = handle->codec_channels;
@@ -448,7 +469,7 @@ error_t read_stream(AudioStreamHandle handle_base, void* out_data, size_t data_s
         }
     }
 
-    if (result == ERROR_NONE && handle->input_gain != 1.0f && bytes_read != nullptr && *bytes_read > 0) {
+    if (handle->input_gain != 1.0f && bytes_read != nullptr && *bytes_read > 0) {
         auto* samples = reinterpret_cast<int16_t*>(out_data);
         size_t sample_count = *bytes_read / sizeof(int16_t);
         for (size_t i = 0; i < sample_count; i++) {
@@ -462,6 +483,7 @@ error_t read_stream(AudioStreamHandle handle_base, void* out_data, size_t data_s
 }
 
 error_t write_stream(AudioStreamHandle handle_base, const void* in_data, size_t data_size, size_t* bytes_written, TickType_t timeout) {
+    if (bytes_written != nullptr) *bytes_written = 0;
     auto* handle = static_cast<AudioStreamHandleImpl*>(handle_base);
     if (handle->direction != AUDIO_CODEC_DIR_OUTPUT || handle->bytes_per_frame == 0) {
         return ERROR_INVALID_STATE;
@@ -532,9 +554,13 @@ error_t write_stream(AudioStreamHandle handle_base, const void* in_data, size_t
         size_t codec_bytes_to_write = codec_frames * handle->codec_bytes_per_frame;
         size_t codec_bytes_written = 0;
         result = audio_codec_write(data->output_codec, handle->codec_buffer.data(), codec_bytes_to_write, &codec_bytes_written, timeout);
-        if (result == ERROR_NONE && bytes_written != nullptr) {
-            // The caller provided `data_size` worth of input; we consumed all of it (resampled/converted).
-            *bytes_written = data_size;
+        if (bytes_written != nullptr && codec_frames > 0) {
+            // A bounded host/hardware queue can accept only part of a converted write,
+            // including when returning ERROR_TIMEOUT. Report progress in app-side whole
+            // frames rather than leaving the count untouched or claiming the entire write.
+            size_t written_frames = codec_bytes_written / handle->codec_bytes_per_frame;
+            if (written_frames > codec_frames) written_frames = codec_frames;
+            *bytes_written = (in_frames * written_frames / codec_frames) * handle->bytes_per_frame;
         }
     }
 
@@ -686,13 +712,17 @@ error_t set_enabled(Device* device, AudioCodecDirection direction, bool enabled)
         data->output_enabled = enabled;
     }
 
-    // Capture and clear the slot under the lock so we hand close_stream() a pointer that
-    // can't simultaneously be torn down by a racing close from the owning app (close_stream
-    // re-checks `*slot == handle` and no-ops if it's already been cleared/replaced).
+    // A pending open has no handle to close yet. Let its owning task clean up when
+    // the codec returns, even if the user re-enables the direction in the meantime.
     AudioStreamHandleImpl* to_close = nullptr;
     if (!enabled) {
         AudioStreamHandleImpl** slot = is_input ? &data->open_input : &data->open_output;
-        to_close = *slot;
+        if (*slot == OPENING_STREAM) {
+            if (is_input) data->input_open_cancelled = true;
+            else data->output_open_cancelled = true;
+        } else {
+            to_close = *slot;
+        }
     }
     xSemaphoreGive(data->mutex);
 

Drivers/es8311-module/bindings/everest,es8311.yaml

@@ -9,3 +9,7 @@ properties:
     type: phandle
     required: true
     description: "I2S controller device that carries audio data"
+  input-gain-percent:
+    type: int
+    default: 100
+    description: "Extra digital gain multiplier applied by audio_stream on top of the ES8311's own 42dB hardware ADC gain, as an integer percentage (100 = 1.0x / no extra boost). For quiet MEMS mic capsules that are still quiet even at max hardware gain."

Drivers/es8311-module/include/drivers/es8311.h

@@ -25,6 +25,14 @@ struct Es8311Config {
     uint8_t address;
     /** I2S controller device that carries audio data */
     struct Device* i2s_device;
+    /**
+     * Extra fixed digital gain multiplier applied by audio_stream on top of the ES8311's
+     * own hardware ADC gain (0..42dB), as an integer percentage (100 = 1.0x / no extra boost).
+     * Small MEMS mic capsules can still sound quiet even near max hardware gain; this is for
+     * boards where 42dB hardware gain alone isn't enough. devicetree has no float property type,
+     * hence the x100 integer encoding.
+     */
+    uint16_t input_gain_percent;
 };
 
 #ifdef __cplusplus

Drivers/es8311-module/source/es8311.cpp

@@ -31,6 +31,7 @@ struct Es8311Data {
     bool is_open = false;
     AudioCodecDirection open_direction = AUDIO_CODEC_DIR_BOTH;
     esp_codec_dev_sample_info_t open_sample_info = {};
+    float input_gain = 1.0f;
 };
 
 #define GET_CONFIG(device) (static_cast<const Es8311Config*>((device)->config))
@@ -144,8 +145,8 @@ error_t set_volume(Device* device, AudioCodecDirection direction, float volume_p
     }
 
     if (direction == AUDIO_CODEC_DIR_INPUT) {
-        // ES8311 ADC gain range is roughly 0..24 dB; map 0..100% linearly onto it.
-        float db = (volume_percent / 100.0f) * 24.0f;
+        // ES8311 ADC gain supports 0..42dB (0,6,12,18,24,30,36,42) in 6dB steps
+        float db = (volume_percent / 100.0f) * 42.0f;
         return (esp_codec_dev_set_in_gain(data->codec_device, db) == ESP_CODEC_DEV_OK) ? ERROR_NONE : ERROR_RESOURCE;
     }
 
@@ -172,7 +173,8 @@ error_t get_volume(Device* device, AudioCodecDirection direction, float* volume_
         if (esp_codec_dev_get_in_gain(data->codec_device, &db) != ESP_CODEC_DEV_OK) {
             return ERROR_RESOURCE;
         }
-        *volume_percent = (db / 24.0f) * 100.0f;
+        *volume_percent = (db / 42.0f) * 100.0f;
+        if (*volume_percent > 100.0f) *volume_percent = 100.0f;
         return ERROR_NONE;
     }
 
@@ -235,6 +237,12 @@ error_t get_capabilities(Device* device, AudioCodecDirection* supported_directio
     return ERROR_NONE;
 }
 
+error_t get_input_gain_multiplier(Device* device, float* gain) {
+    auto* data = GET_DATA(device);
+    *gain = data->input_gain;
+    return ERROR_NONE;
+}
+
 static const struct AudioCodecApi API = {
     .open = open,
     .close = close,
@@ -247,7 +255,7 @@ static const struct AudioCodecApi API = {
     .get_native_sample_rate = get_native_sample_rate,
     .get_native_channels = get_native_channels,
     .get_capabilities = get_capabilities,
-    .get_input_gain_multiplier = nullptr,
+    .get_input_gain_multiplier = get_input_gain_multiplier,
 };
 
 // endregion
@@ -257,6 +265,11 @@ static const struct AudioCodecApi API = {
 error_t start_device(Device* device) {
     const auto* config = GET_CONFIG(device);
 
+    if (config->input_gain_percent > 2000) {
+        LOG_E(TAG, "Invalid input_gain_percent %u (must be 0..2000)", config->input_gain_percent);
+        return ERROR_RESOURCE;
+    }
+
     auto* i2c_controller = device_get_parent(device);
     if (i2c_controller == nullptr || device_get_type(i2c_controller) != &I2C_CONTROLLER_TYPE) {
         LOG_E(TAG, "Parent is not an I2C controller");
@@ -270,6 +283,8 @@ error_t start_device(Device* device) {
     }
 
     auto* data = new Es8311Data();
+    data->input_gain = (float) config->input_gain_percent / 100.0f;
+    if (config->input_gain_percent == 0) data->input_gain = 1.0f; // 0 means unset
 
     data->ctrl_if = audio_codec_adapter_new_i2c_ctrl(i2c_controller, config->address);
     data->data_if = audio_codec_adapter_new_i2s_data(i2s_controller);

Modules/app-module/CMakeLists.txt

@@ -10,15 +10,29 @@ tactility_add_module(app-module
     INCLUDE_DIRS include/
     REQUIRES TactilityKernel service-module minitar
     PRIV_REQUIRES TactilityKernelCpp
+    WHOLE_ARCHIVE
 )
 
-# Tells source/io.cpp its real-syscall fallback must go through __real_read/write/close()
-# rather than calling ::read/::write/::close() directly, on every platform whose build wraps
-# those symbols (ESP-IDF always; POSIX except macOS, whose linker doesn't support --wrap) -
-# see Tactility/CMakeLists.txt and the top-level CMakeLists.txt for where that's applied.
-if (NOT APPLE)
+# Tells source/io.cpp its real-syscall fallback must go through __real_read/write/close() rather
+# than calling ::read/::write/::close() directly, on every platform where those are wrapped: via
+# -Wl,--wrap= on ESP-IDF (see the top-level CMakeLists.txt) and non-Apple POSIX (below), or via
+# source/stdio_wrap.cpp's dyld interpose on Apple (whose linker lacks --wrap).
+tactility_get_module_name(app-module MODULE_NAME)
+target_compile_definitions(${MODULE_NAME} PRIVATE TT_APP_IO_WRAPS_STDIO)
+
+# Routes every read()/write()/close() and printf-family call to source/stdio_wrap.cpp's __wrap_*
+# functions; see that file for what they do and why. ESP-IDF wraps the same symbols itself (see
+# the top-level CMakeLists.txt); Apple gets the same routing via dyld interpose instead, self-
+# registered in that file. PUBLIC so every consumer of this module (Tactility, and any test target
+# that links app-module directly) gets the flags too.
+if (NOT ESP_PLATFORM AND NOT APPLE)
     tactility_get_module_name(app-module MODULE_NAME)
-    target_compile_definitions(${MODULE_NAME} PRIVATE TT_APP_IO_WRAPS_STDIO)
+    target_link_options(${MODULE_NAME} PUBLIC
+        "-Wl,--wrap=read" "-Wl,--wrap=write" "-Wl,--wrap=close"
+        "-Wl,--wrap=printf" "-Wl,--wrap=fprintf" "-Wl,--wrap=vprintf" "-Wl,--wrap=vfprintf"
+        "-Wl,--wrap=puts" "-Wl,--wrap=fputs" "-Wl,--wrap=putchar" "-Wl,--wrap=fputc"
+        "-Wl,--wrap=getchar" "-Wl,--wrap=fgetc" "-Wl,--wrap=fgets"
+    )
 endif ()
 
 # install.cpp resolves an installed binary's fixed bin/<platform>/<binary>.so path itself, so it

Modules/app-module/source/io.cpp

@@ -8,13 +8,42 @@
 #include <cerrno>
 
 #if defined(TT_APP_IO_WRAPS_STDIO)
+#ifdef ESP_PLATFORM
+// Newlib's stdio (fflush()'s buffer-flush path, in particular) calls the reentrant _read_r/
+// _write_r/_close_r syscall stubs directly. The plain read()/write()/close() newlib provides are
+// just thin wrappers around them (esp-idf's components/newlib/src/syscalls.c: `write(fd, dst,
+// size) { return _write_r(__getreent(), fd, dst, size); }`). Wrapping the _r stubs catches both;
+// wrapping the plain names would only catch direct write()-style callers.
+#include <reent.h>
+extern "C" {
+ssize_t __real__read_r(struct _reent* r, int fd, void* buffer, size_t size);
+ssize_t __real__write_r(struct _reent* r, int fd, const void* buffer, size_t size);
+int __real__close_r(struct _reent* r, int fd);
+}
+namespace {
+ssize_t real_read(int fd, void* buffer, size_t size) { return __real__read_r(__getreent(), fd, buffer, size); }
+ssize_t real_write(int fd, const void* buffer, size_t size) { return __real__write_r(__getreent(), fd, buffer, size); }
+int real_close(int fd) { return __real__close_r(__getreent(), fd); }
+} // namespace
+#else
 extern "C" {
 ssize_t __real_read(int fd, void* buffer, size_t size);
 ssize_t __real_write(int fd, const void* buffer, size_t size);
 int __real_close(int fd);
 }
+namespace {
+ssize_t real_read(int fd, void* buffer, size_t size) { return __real_read(fd, buffer, size); }
+ssize_t real_write(int fd, const void* buffer, size_t size) { return __real_write(fd, buffer, size); }
+int real_close(int fd) { return __real_close(fd); }
+} // namespace
+#endif
 #else
 #include <unistd.h>
+namespace {
+ssize_t real_read(int fd, void* buffer, size_t size) { return ::read(fd, buffer, size); }
+ssize_t real_write(int fd, const void* buffer, size_t size) { return ::write(fd, buffer, size); }
+int real_close(int fd) { return ::close(fd); }
+} // namespace
 #endif
 
 namespace {
@@ -56,11 +85,7 @@ ssize_t app_io_read(int fd, void* buffer, size_t size) {
         errno = EBADF;
         return -1;
     }
-#if defined(TT_APP_IO_WRAPS_STDIO)
-    return __real_read(fd, buffer, size);
-#else
-    return ::read(fd, buffer, size);
-#endif
+    return real_read(fd, buffer, size);
 }
 
 ssize_t app_io_write(int fd, const void* buffer, size_t size) {
@@ -78,22 +103,14 @@ ssize_t app_io_write(int fd, const void* buffer, size_t size) {
         // output is currently being intercepted. Without this, a log line emitted while any app
         // instance has its stdout captured would vanish from the console entirely instead of
         // just also being visible to the capturing parent.
-#if defined(TT_APP_IO_WRAPS_STDIO)
-        __real_write(fd, buffer, size);
-#else
-        ::write(fd, buffer, size);
-#endif
+        real_write(fd, buffer, size);
         return result;
     }
     if (table != nullptr && app_fd_table_is_app_owned(table, fd)) {
         errno = EBADF;
         return -1;
     }
-#if defined(TT_APP_IO_WRAPS_STDIO)
-    return __real_write(fd, buffer, size);
-#else
-    return ::write(fd, buffer, size);
-#endif
+    return real_write(fd, buffer, size);
 }
 
 int app_io_close(int fd) {
@@ -108,11 +125,7 @@ int app_io_close(int fd) {
             return -1;
         }
     }
-#if defined(TT_APP_IO_WRAPS_STDIO)
-    return __real_close(fd);
-#else
-    return ::close(fd);
-#endif
+    return real_close(fd);
 }
 
 } // extern "C"

Modules/app-module/source/stdio_wrap.cpp

@@ -0,0 +1,327 @@
+// SPDX-License-Identifier: Apache-2.0
+
+// Paired with -Wl,--wrap= on POSIX (this module's own CMakeLists.txt) and ESP32 (top-level
+// CMakeLists.txt); self-registered via dyld interpose below on Apple, whose linker doesn't
+// support --wrap.
+#include <app/io.h>
+
+#include <sys/types.h>
+
+#ifdef ESP_PLATFORM
+
+// Newlib's own stdio (fflush()'s buffer-flush path, in particular) calls the reentrant
+// _read_r/_write_r/_close_r syscall stubs directly, not the plain read()/write()/close() newlib
+// itself provides as thin wrappers around them (see e.g. esp-idf's components/newlib/src/
+// syscalls.c: `write(fd, dst, size) { return _write_r(__getreent(), fd, dst, size); }`)
+// Wrapping the plain names only catches direct write()-style callers, not newlib's own internal
+// stdio calls, so the _r stubs are wrapped here instead.
+#include <reent.h>
+
+extern "C" {
+
+ssize_t __wrap__read_r(struct _reent* r, int fd, void* buffer, size_t size) {
+    (void)r;
+    return app_io_read(fd, buffer, size);
+}
+
+ssize_t __wrap__write_r(struct _reent* r, int fd, const void* buffer, size_t size) {
+    (void)r;
+    return app_io_write(fd, buffer, size);
+}
+
+int __wrap__close_r(struct _reent* r, int fd) {
+    (void)r;
+    return app_io_close(fd);
+}
+
+}
+
+#else
+
+extern "C" {
+
+ssize_t __wrap_read(int fd, void* buffer, size_t size) {
+    return app_io_read(fd, buffer, size);
+}
+
+ssize_t __wrap_write(int fd, const void* buffer, size_t size) {
+    return app_io_write(fd, buffer, size);
+}
+
+int __wrap_close(int fd) {
+    return app_io_close(fd);
+}
+
+}
+
+#endif // ESP_PLATFORM
+
+#ifdef __APPLE__
+
+// --wrap also synthesizes __real_read/write/close automatically; dyld interpose doesn't, so
+// io.cpp's TT_APP_IO_WRAPS_STDIO fallback needs them defined here. dlsym(RTLD_NEXT, ...) is the
+// standard way to reach the true libSystem implementation despite the interpose below: a direct
+// call to read/write/close from this file would just recurse into __wrap_read/write/close, since
+// interpose rewrites every reference to those symbols in the process, this file included.
+#include <dlfcn.h>
+#include <unistd.h>
+
+extern "C" {
+
+ssize_t __real_read(int fd, void* buffer, size_t size) {
+    static auto real = reinterpret_cast<ssize_t (*)(int, void*, size_t)>(dlsym(RTLD_NEXT, "read"));
+    return real(fd, buffer, size);
+}
+
+ssize_t __real_write(int fd, const void* buffer, size_t size) {
+    static auto real = reinterpret_cast<ssize_t (*)(int, const void*, size_t)>(dlsym(RTLD_NEXT, "write"));
+    return real(fd, buffer, size);
+}
+
+int __real_close(int fd) {
+    static auto real = reinterpret_cast<int (*)(int)>(dlsym(RTLD_NEXT, "close"));
+    return real(fd);
+}
+
+}
+
+// <mach-o/dyld-interposing.h> isn't a public SDK header (it ships with dyld's own source, not
+// Xcode/Command Line Tools), so this reimplements its DYLD_INTERPOSE macro locally; reused below
+// for the printf-family interposes too.
+#define TT_DYLD_INTERPOSE(replacement, replacee) \
+    __attribute__((used)) static struct { const void* replacement; const void* replacee; } \
+        tt_interpose_##replacee __attribute__((section("__DATA,__interpose"))) = { \
+            (const void*)(unsigned long)&(replacement), (const void*)(unsigned long)&(replacee) \
+        };
+
+TT_DYLD_INTERPOSE(__wrap_read, read)
+TT_DYLD_INTERPOSE(__wrap_write, write)
+TT_DYLD_INTERPOSE(__wrap_close, close)
+
+#endif // __APPLE__
+
+// region glibc stdio wraps
+//
+// libc's printf/fprintf/etc are compiled into the C library and call an internal, non-exported
+// write() alias, which --wrap=write/the read/write/close interpose above can't reach: only calls
+// WE make to the public symbol. These wraps instead redirect calls WE make to printf/fprintf/etc,
+// the same trick as read/write/close above. Newlib (ESP-IDF) doesn't have this gap: its stdio does
+// call the wrappable syscall stubs, so this block is POSIX-only.
+//
+// Scoped to the printf/getc families only: fread/fwrite take an arbitrary FILE* and are already
+// used sitewide for real file I/O (e.g. File.cpp's readBinaryInternal), so wrapping them would
+// route every such call through this file's stdin/stdout check, a correctness risk for unrelated
+// code that isn't worth taking here. putc/getc are excluded too since libc defines them as
+// macros, not real calls, so wrapping those symbols wouldn't reliably intercept them.
+
+#if !defined(ESP_PLATFORM)
+
+#include <cstdarg>
+#include <cstdio>
+#include <cstring>
+#include <memory>
+#include <unistd.h>
+
+extern "C" {
+int __real_vfprintf(FILE* stream, const char* format, va_list args);
+int __real_fputs(const char* s, FILE* stream);
+int __real_fputc(int c, FILE* stream);
+int __real_fgetc(FILE* stream);
+char* __real_fgets(char* buffer, int size, FILE* stream);
+}
+
+#ifdef __APPLE__
+
+// --wrap synthesizes these automatically elsewhere; on Apple they're defined here via
+// dlsym(RTLD_NEXT, ...) instead. See the read/write/close __real_* block above for why.
+#include <dlfcn.h>
+
+extern "C" {
+
+int __real_vfprintf(FILE* stream, const char* format, va_list args) {
+    static auto real = reinterpret_cast<int (*)(FILE*, const char*, va_list)>(dlsym(RTLD_NEXT, "vfprintf"));
+    return real(stream, format, args);
+}
+
+int __real_fputs(const char* s, FILE* stream) {
+    static auto real = reinterpret_cast<int (*)(const char*, FILE*)>(dlsym(RTLD_NEXT, "fputs"));
+    return real(s, stream);
+}
+
+int __real_fputc(int c, FILE* stream) {
+    static auto real = reinterpret_cast<int (*)(int, FILE*)>(dlsym(RTLD_NEXT, "fputc"));
+    return real(c, stream);
+}
+
+int __real_fgetc(FILE* stream) {
+    static auto real = reinterpret_cast<int (*)(FILE*)>(dlsym(RTLD_NEXT, "fgetc"));
+    return real(stream);
+}
+
+char* __real_fgets(char* buffer, int size, FILE* stream) {
+    static auto real = reinterpret_cast<char* (*)(char*, int, FILE*)>(dlsym(RTLD_NEXT, "fgets"));
+    return real(buffer, size, stream);
+}
+
+}
+
+#endif // __APPLE__
+
+namespace {
+
+void writeAllToStdout(const void* data, size_t size) {
+    const auto* bytes = static_cast<const char*>(data);
+    size_t remaining = size;
+    while (remaining > 0) {
+        ssize_t written = app_io_write(STDOUT_FILENO, bytes, remaining);
+        if (written <= 0) {
+            break;
+        }
+        bytes += written;
+        remaining -= static_cast<size_t>(written);
+    }
+}
+
+// Formats into stdout via app_io_write() rather than through a FILE*'s own buffering, since that
+// buffering is exactly what glibc's internal write() call sidesteps --wrap for in the first place.
+int formatToStdout(const char* format, va_list args) {
+    char stackBuffer[256];
+    va_list argsForStack;
+    va_copy(argsForStack, args);
+    int needed = vsnprintf(stackBuffer, sizeof(stackBuffer), format, argsForStack);
+    va_end(argsForStack);
+    if (needed < 0) {
+        return needed;
+    }
+    if (static_cast<size_t>(needed) < sizeof(stackBuffer)) {
+        writeAllToStdout(stackBuffer, static_cast<size_t>(needed));
+        return needed;
+    }
+    auto heapBuffer = std::make_unique<char[]>(static_cast<size_t>(needed) + 1);
+    va_list argsForHeap;
+    va_copy(argsForHeap, args);
+    vsnprintf(heapBuffer.get(), static_cast<size_t>(needed) + 1, format, argsForHeap);
+    va_end(argsForHeap);
+    writeAllToStdout(heapBuffer.get(), static_cast<size_t>(needed));
+    return needed;
+}
+
+int readOneFromStdin(char& out) {
+    return static_cast<int>(app_io_read(STDIN_FILENO, &out, 1));
+}
+
+} // namespace
+
+extern "C" {
+
+int __wrap_vprintf(const char* format, va_list args) {
+    return formatToStdout(format, args);
+}
+
+int __wrap_printf(const char* format, ...) {
+    va_list args;
+    va_start(args, format);
+    int result = formatToStdout(format, args);
+    va_end(args);
+    return result;
+}
+
+int __wrap_vfprintf(FILE* stream, const char* format, va_list args) {
+    if (stream == stdout) {
+        return formatToStdout(format, args);
+    }
+    return __real_vfprintf(stream, format, args);
+}
+
+int __wrap_fprintf(FILE* stream, const char* format, ...) {
+    va_list args;
+    va_start(args, format);
+    int result = (stream == stdout) ? formatToStdout(format, args) : __real_vfprintf(stream, format, args);
+    va_end(args);
+    return result;
+}
+
+int __wrap_puts(const char* s) {
+    writeAllToStdout(s, strlen(s));
+    writeAllToStdout("\n", 1);
+    return 0;
+}
+
+int __wrap_fputs(const char* s, FILE* stream) {
+    if (stream == stdout) {
+        writeAllToStdout(s, strlen(s));
+        return 0;
+    }
+    return __real_fputs(s, stream);
+}
+
+int __wrap_putchar(int c) {
+    auto ch = static_cast<char>(c);
+    writeAllToStdout(&ch, 1);
+    return c;
+}
+
+int __wrap_fputc(int c, FILE* stream) {
+    if (stream == stdout) {
+        return __wrap_putchar(c);
+    }
+    return __real_fputc(c, stream);
+}
+
+int __wrap_getchar() {
+    char c;
+    return readOneFromStdin(c) == 1 ? static_cast<unsigned char>(c) : EOF;
+}
+
+int __wrap_fgetc(FILE* stream) {
+    if (stream == stdin) {
+        return __wrap_getchar();
+    }
+    return __real_fgetc(stream);
+}
+
+char* __wrap_fgets(char* buffer, int size, FILE* stream) {
+    if (stream != stdin) {
+        return __real_fgets(buffer, size, stream);
+    }
+    if (size <= 0) {
+        return nullptr;
+    }
+    int i = 0;
+    for (; i < size - 1; ++i) {
+        char c;
+        if (readOneFromStdin(c) != 1) {
+            break;
+        }
+        buffer[i] = c;
+        if (c == '\n') {
+            ++i;
+            break;
+        }
+    }
+    if (i == 0) {
+        return nullptr;
+    }
+    buffer[i] = '\0';
+    return buffer;
+}
+
+}
+
+#ifdef __APPLE__
+TT_DYLD_INTERPOSE(__wrap_vprintf, vprintf)
+TT_DYLD_INTERPOSE(__wrap_printf, printf)
+TT_DYLD_INTERPOSE(__wrap_vfprintf, vfprintf)
+TT_DYLD_INTERPOSE(__wrap_fprintf, fprintf)
+TT_DYLD_INTERPOSE(__wrap_puts, puts)
+TT_DYLD_INTERPOSE(__wrap_fputs, fputs)
+TT_DYLD_INTERPOSE(__wrap_putchar, putchar)
+TT_DYLD_INTERPOSE(__wrap_fputc, fputc)
+TT_DYLD_INTERPOSE(__wrap_getchar, getchar)
+TT_DYLD_INTERPOSE(__wrap_fgetc, fgetc)
+TT_DYLD_INTERPOSE(__wrap_fgets, fgets)
+#endif // __APPLE__
+
+#endif // !ESP_PLATFORM
+
+// endregion

Modules/app-module/tests/CMakeLists.txt

@@ -6,30 +6,12 @@ enable_language(C CXX ASM)
 file(GLOB_RECURSE TEST_SOURCES CONFIGURE_DEPENDS ${PROJECT_SOURCE_DIR}/source/*.cpp)
 add_executable(AppModuleTests EXCLUDE_FROM_ALL ${TEST_SOURCES})
 
-if (NOT APPLE)
-    # Provides __wrap_read/write/close for the -Wl,--wrap= below (see Tactility/CMakeLists.txt
-    # for the canonical pairing of this file with those flags).
-    target_sources(AppModuleTests PRIVATE ${CMAKE_CURRENT_LIST_DIR}/../../../Tactility/Source/AppStdioWrap.cpp)
-endif ()
-
 target_include_directories(AppModuleTests PRIVATE ${DOCTESTINC} ${CMAKE_CURRENT_LIST_DIR}/../private)
 
 add_test(NAME AppModuleTests COMMAND AppModuleTests)
 
-# Matches app-module's own TT_APP_IO_WRAPS_STDIO (see Modules/app-module/CMakeLists.txt):
-# io.cpp calls __real_read/write/close() on non-Apple POSIX, so any final link of it needs
-# these wraps too, or those symbols go unresolved. The printf-family/getc-family flags are
-# needed for the same reason: AppStdioWrap.cpp compiles those __wrap_* functions unconditionally
-# on this platform (see its own #if guard), and they reference __real_vfprintf/fputs/fputc/
-# fgetc/fgets - those only exist once the matching --wrap flag is passed.
-if (NOT APPLE)
-    target_link_options(AppModuleTests PRIVATE
-        "-Wl,--wrap=read" "-Wl,--wrap=write" "-Wl,--wrap=close"
-        "-Wl,--wrap=printf" "-Wl,--wrap=fprintf" "-Wl,--wrap=vprintf" "-Wl,--wrap=vfprintf"
-        "-Wl,--wrap=puts" "-Wl,--wrap=fputs" "-Wl,--wrap=putchar" "-Wl,--wrap=fputc"
-        "-Wl,--wrap=getchar" "-Wl,--wrap=fgetc" "-Wl,--wrap=fgets"
-    )
-endif ()
+# No --wrap flags or stdio_wrap.cpp source needed here: linking app-module below already brings
+# both along (see its own CMakeLists.txt).
 
 target_link_libraries(AppModuleTests PUBLIC
     TactilityKernel

Modules/app-module/tests/source/execute_test.cpp

@@ -15,6 +15,7 @@
 #include <tactility/delay.h>
 #include <tactility/freertos/task.h>
 
+#include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <string>
@@ -110,6 +111,11 @@ int32_t stream_writer_app_main(int, char*[]) {
     return 7;
 }
 
+int32_t printf_stream_writer_app_main(int, char*[]) {
+    printf("loc");
+    return 7;
+}
+
 // Writes argv[0] to its own stdout, for the app_execute_with_streams() argv-delivery test.
 int32_t argv_echo_app_main(int argc, char* argv[]) {
     if (argc < 1) {
@@ -321,3 +327,53 @@ TEST_CASE("app_execute_for_result_with_streams delivers both the stream data and
     app_manager_stop(parent_id);
     app_manager_remove("test.app.execute.parent_streams");
 }
+
+TEST_CASE("app_execute_for_result_with_streams pipes a child's plain printf() calls too") {
+    ensure_memory_loader_registered();
+
+    AppManifest parent_manifest { "test.app.execute.printf_parent", "Parent", APP_CATEGORY_USER, { APP_LOCATION_MEMORY, reinterpret_cast<void*>(location_app_main) } };
+    REQUIRE_EQ(app_manager_add(&parent_manifest), ERROR_NONE);
+
+    uint32_t parent_id = 0;
+    REQUIRE_EQ(app_start("test.app.execute.printf_parent", 0, nullptr, &parent_id), ERROR_NONE);
+    CHECK(wait_for_state(parent_id, APP_INSTANCE_STATE_ACTIVE, 1000));
+
+    TaskEventGroup parent_event_group {};
+    task_event_group_construct(&parent_event_group);
+    AppEventSubscription parent_sub {};
+    REQUIRE_EQ(app_event_subscribe_with_app_id(&parent_sub, &parent_event_group, parent_id), ERROR_NONE);
+
+    uint8_t storage[64];
+    AppStream child_stdout {};
+    AppStreamBinding binding { STDOUT_FILENO, &child_stdout, storage, sizeof(storage), &parent_event_group };
+
+    AppLocation location { APP_LOCATION_MEMORY, reinterpret_cast<void*>(printf_stream_writer_app_main) };
+    uint32_t child_id = 0;
+    REQUIRE_EQ(app_execute_for_result_with_streams(location, AppStackConfig {}, 0, nullptr, &binding, 1, parent_id, &child_id), ERROR_NONE);
+
+    std::vector<uint8_t> received;
+    while (app_stream_await(&child_stdout, APP_FILE_WAIT_READABLE, pdMS_TO_TICKS(1000)) == ERROR_NONE) {
+        uint8_t chunk[16];
+        size_t n = app_stream_read(&child_stdout, chunk, sizeof(chunk));
+        if (n == 0) {
+            break; // EOF
+        }
+        received.insert(received.end(), chunk, chunk + n);
+    }
+    REQUIRE_EQ(received.size(), 3u);
+    CHECK_EQ(std::memcmp(received.data(), "loc", 3), 0);
+
+    REQUIRE_EQ(task_event_group_wait(&parent_event_group, parent_sub.bit, false, nullptr, pdMS_TO_TICKS(2000)), ERROR_NONE);
+    AppEvent event {};
+    REQUIRE_EQ(app_event_poll(&parent_sub, &event), ERROR_NONE);
+    CHECK_EQ(event.type, APP_EVENT_RESULT);
+    CHECK_EQ(event.result.launch_id, child_id);
+    CHECK_EQ(event.result.result, 7);
+
+    app_stream_unsubscribe(&child_stdout);
+    app_event_unsubscribe(&parent_sub);
+    task_event_group_destruct(&parent_event_group);
+    app_manager_stop(child_id);
+    app_manager_stop(parent_id);
+    app_manager_remove("test.app.execute.printf_parent");
+}

Modules/app-module/tests/source/io_test.cpp

@@ -16,6 +16,7 @@
 #include <unistd.h>
 
 #include <atomic>
+#include <cstdio>
 #include <cstring>
 #include <vector>
 
@@ -66,6 +67,11 @@ int32_t stdout_writer_app_main(int, char*[]) {
     return 0;
 }
 
+int32_t stdout_printf_app_main(int, char*[]) {
+    printf("hello");
+    return 0;
+}
+
 std::atomic<bool> g_blocked_writer_saw_error { false };
 std::atomic<bool> g_blocked_writer_done { false };
 
@@ -180,6 +186,41 @@ TEST_CASE("app_start_with_streams pipes a child's app_io_write() calls into a pa
     app_manager_remove("test.io.writer");
 }
 
+TEST_CASE("app_start_with_streams pipes a child's plain printf() calls into a parent-owned AppStream") {
+    ensure_memory_loader_registered();
+
+    AppManifest manifest { "test.io.printf_writer", "PrintfWriter", APP_CATEGORY_USER, { APP_LOCATION_MEMORY, reinterpret_cast<void*>(stdout_printf_app_main) } };
+    REQUIRE_EQ(app_manager_add(&manifest), ERROR_NONE);
+
+    TaskEventGroup event_group {};
+    task_event_group_construct(&event_group);
+
+    uint8_t storage[64];
+    AppStream child_stdout {};
+
+    AppStreamBinding binding { STDOUT_FILENO, &child_stdout, storage, sizeof(storage), &event_group };
+    AppInstanceId child_id = 0;
+    REQUIRE_EQ(app_start_with_streams("test.io.printf_writer", &binding, 1, &child_id), ERROR_NONE);
+
+    std::vector<uint8_t> received;
+    while (app_stream_await(&child_stdout, APP_FILE_WAIT_READABLE, pdMS_TO_TICKS(1000)) == ERROR_NONE) {
+        uint8_t chunk[16];
+        size_t n = app_stream_read(&child_stdout, chunk, sizeof(chunk));
+        if (n == 0) {
+            break; // EOF
+        }
+        received.insert(received.end(), chunk, chunk + n);
+    }
+
+    REQUIRE_EQ(received.size(), 5u);
+    CHECK_EQ(std::memcmp(received.data(), "hello", 5), 0);
+
+    REQUIRE(wait_for_state(child_id, APP_INSTANCE_STATE_STOPPED, 1000));
+    app_stream_unsubscribe(&child_stdout);
+    task_event_group_destruct(&event_group);
+    app_manager_remove("test.io.printf_writer");
+}
+
 TEST_CASE("a write blocked on a full stream wakes with an error once the consumer closes it") {
     ensure_memory_loader_registered();
     g_blocked_writer_saw_error.store(false, std::memory_order_relaxed);

Platforms/platform-posix/CMakeLists.txt

@@ -6,3 +6,12 @@ add_library(platform-posix OBJECT)
 target_sources(platform-posix PRIVATE ${SOURCES})
 #target_include_directories(platform-posix PUBLIC include/)
 target_link_libraries(platform-posix PUBLIC TactilityKernel)
+
+# Routes every pthread_attr_setstack() call to __wrap_pthread_attr_setstack() in source/pthread_stack_wrap.c,
+# which no-ops it. see that file for why.
+# --wrap is a GNU ld option; Apple's linker doesn't support it, so that file instead self-registers a dyld interpose
+# for this symbol on Apple, needing no link flag. PUBLIC so every consumer of this OBJECT library
+# (Tactility, and every test target that links platform-posix directly) gets it applied too.
+if (NOT APPLE)
+    target_link_options(platform-posix PUBLIC "-Wl,--wrap=pthread_attr_setstack")
+endif ()

Platforms/platform-posix/source/pthread_stack_wrap.c

@@ -2,20 +2,15 @@
 #include <stddef.h>
 
 /**
- * Linked in with -Wl,--wrap=pthread_attr_setstack (see Tactility/CMakeLists.txt).
+ * FreeRTOS's POSIX port hands every task a stack carved from its own heap (pvPortMalloc) via this call.
+ * pthread_attr_setstack requires page alignment that pvPortMalloc doesn't guarantee.
+ * When it succeeds anyway, the task's real pthread stack ends up living inside that small FreeRTOS heap region,
+ * where a thread doing heavier stack work (e.g. Mesa GL shader compilation) can silently corrupt adjacent heap_4 objects.
+ * No-op'ing the call instead leaves every task's pthread_attr_t at its pthread_attr_init() default,
+ * so pthread_create() gives it a real, properly sized stack.
  *
- * FreeRTOS's POSIX port (Libraries/FreeRTOS-Kernel/portable/ThirdParty/GCC/Posix/port.c)
- * hands every task a stack carved out of its own heap (pvPortMalloc) via this call.
- * pthread_attr_setstack requires page alignment, which pvPortMalloc doesn't guarantee;
- * when it happens to succeed anyway (allocator alignment can vary run to run), the
- * task's real pthread stack ends up living inside that small FreeRTOS heap region -
- * fine for typical embedded task code, but a desktop GL driver doing on-the-fly shader
- * compilation on that thread (e.g. Mesa on first frame present) can overflow it and
- * silently corrupt adjacent heap_4 objects.
- *
- * Wrapping the call out entirely (rather than patching the vendored port.c) leaves every
- * task's pthread_attr_t at its pthread_attr_init() default, so pthread_create() always
- * gives it a real, properly allocated default-size stack instead.
+ * Linked via -Wl,--wrap=pthread_attr_setstack (this module's own CMakeLists.txt) on non-Apple
+ * platforms; reused as a dyld interpose target below on Apple platforms, whose linker lacks --wrap.
  */
 int __wrap_pthread_attr_setstack(pthread_attr_t* attr, void* stackaddr, size_t stacksize) {
     (void)attr;
@@ -23,3 +18,17 @@ int __wrap_pthread_attr_setstack(pthread_attr_t* attr, void* stackaddr, size_t s
     (void)stacksize;
     return 0;
 }
+
+#ifdef __APPLE__
+
+// <mach-o/dyld-interposing.h> isn't a public SDK header (it ships with dyld's own source, not
+// Xcode/Command Line Tools), so this reimplements its DYLD_INTERPOSE macro locally.
+#define TT_DYLD_INTERPOSE(replacement, replacee) \
+    __attribute__((used)) static struct { const void* replacement; const void* replacee; } \
+        tt_interpose_##replacee __attribute__((section("__DATA,__interpose"))) = { \
+            (const void*)(unsigned long)&(replacement), (const void*)(unsigned long)&(replacee) \
+        };
+
+TT_DYLD_INTERPOSE(__wrap_pthread_attr_setstack, pthread_attr_setstack)
+
+#endif

Tactility/CMakeLists.txt

@@ -185,31 +185,9 @@ else ()
     # Exports Tactility's own symbols (-rdynamic) so a dlopen()ed app-posix-module app can resolve
     # calls back into it - the OS-native equivalent of app-esp32-module's custom symbol resolver.
     set_target_properties(Tactility PROPERTIES ENABLE_EXPORTS ON)
-    # Routes every pthread_attr_setstack() call (FreeRTOS's POSIX port hands each task a stack
-    # carved out of its own heap through this) to __wrap_pthread_attr_setstack() in
-    # Platforms/platform-posix/source/pthread_stack_wrap.c, which no-ops it - see that file for why.
-    # --wrap is a GNU ld option; Apple's linker doesn't support it.
-    if (NOT APPLE)
-        target_link_options(Tactility PRIVATE "-Wl,--wrap=pthread_attr_setstack")
-        # Routes every read()/write()/close() call to Tactility/Source/AppStdioWrap.cpp's
-        # __wrap_read/write/close(), which forward into app_io_read/write/close() - the fd-table
-        # dispatch that lets an app's own stdio (e.g. a fileselection dialog's printf'd result
-        # path) reach an AppStream a parent bound via app_manager_start_with_streams(). Mirrors
-        # what ESP-IDF's build already does for the ESP32 target (see top-level CMakeLists.txt).
-        target_link_options(Tactility PRIVATE "-Wl,--wrap=read" "-Wl,--wrap=write" "-Wl,--wrap=close")
-        # glibc's printf/fprintf/etc don't call the public write() symbol internally (they're
-        # already compiled into libc.so, out of --wrap's reach), so the read/write/close wrap
-        # above can't see them. Newlib (ESP-IDF) doesn't have this gap - its stdio does call the
-        # wrappable syscall stubs - so this block is POSIX-only. Wrapping these symbols instead
-        # redirects OUR OWN calls to them (the only ones --wrap can rewrite) through
-        # AppStdioWrap.cpp's __wrap_* functions, which check the target stream (stdout/stdin) and
-        # fall back to the real libc function for any other FILE*.
-        target_link_options(Tactility PRIVATE
-            "-Wl,--wrap=printf" "-Wl,--wrap=fprintf" "-Wl,--wrap=vprintf" "-Wl,--wrap=vfprintf"
-            "-Wl,--wrap=puts" "-Wl,--wrap=fputs" "-Wl,--wrap=putchar" "-Wl,--wrap=fputc"
-            "-Wl,--wrap=getchar" "-Wl,--wrap=fgetc" "-Wl,--wrap=fgets"
-        )
-    endif ()
+    # pthread_attr_setstack and read/write/close/printf-family aren't wrapped here: linking
+    # platform-posix and app-module already brings those wraps along (see their own
+    # CMakeLists.txt files).
 endif ()
 
 #

Tactility/Include/Tactility/settings/DisplaySettings.h

@@ -19,6 +19,7 @@ enum class ScreensaverType {
     MatrixRain,
     StackChan,
     McpScreen,
+    BibleVerse,     // Launch the Bible Verse app (if installed)
     Count           // Sentinel for bounds checking - must be last
 };
 
@@ -37,6 +38,14 @@ struct DisplaySettings {
     bool backlightTimeoutEnabled;
     uint32_t backlightTimeoutMs; // 0 = Never
     ScreensaverType screensaverType = ScreensaverType::BouncingBalls;
+    // Night dim: when enabled and the local hour falls inside
+    // [nightDimStartHour, nightDimEndHour), the screensaver runs at
+    // nightDimDuty instead of backlightDuty. A start == end window
+    // means the whole day.
+    bool nightDimEnabled = false;
+    uint8_t nightDimStartHour = 22;
+    uint8_t nightDimEndHour = 7;
+    uint8_t nightDimDuty = 20;
 };
 
 /** Compares default settings with the function parameter to return the difference */

Tactility/Include/Tactility/settings/SystemSettings.h

@@ -6,7 +6,7 @@ namespace tt::settings {
 
 struct SystemSettings {
     Language language = Language::en_US;
-    bool timeFormat24h = true;
+    bool timeFormat24h = false;
     std::string dateFormat = std::string("DD/MM/YYYY"); // MM/DD/YYYY, DD/MM/YYYY, YYYY-MM-DD, YYYY/MM/DD
 };
 

Tactility/Private/Tactility/app/files/SupportedFiles.h

@@ -7,5 +7,6 @@ namespace tt::app::files {
 bool isSupportedAppFile(const std::string& filename);
 bool isSupportedImageFile(const std::string& filename);
 bool isSupportedTextFile(const std::string& filename);
+bool isSupportedAudioFile(const std::string& filename);
 
 } // namespace

Tactility/Private/Tactility/mcp/McpSystem.h

@@ -13,7 +13,7 @@ namespace tt::mcp {
 struct McpSystemState {
     std::mutex mutex;
     bool overrideActive = false;
-
+    
     // UI elements when McpOverrideApp is active
     lv_obj_t* drawArea = nullptr;
     uint16_t* framebuffer = nullptr;
@@ -23,7 +23,7 @@ struct McpSystemState {
     uint16_t drawWidth = 320;
     uint16_t drawHeight = 240;
     int drawColor = 1; // 0 = white, 1 = black
-
+    
     // Audio device status
     Device* i2sDevice = nullptr;
     Device* audioStreamDevice = nullptr;

Tactility/Private/Tactility/service/displayidle/DisplayIdleService.h

@@ -5,6 +5,8 @@
 #include <Tactility/settings/DisplaySettings.h>
 #include <Tactility/Timer.h>
 
+#include <app/instance.h>
+
 #include <atomic>
 #include <memory>
 
@@ -29,9 +31,15 @@ class DisplayIdleService final : public Service {
     // Active screensaver instance
     std::unique_ptr<Screensaver> screensaver;
 
-    // Screensaver auto-off: turn off backlight after 5 minutes of screensaver
+    // App launched as screensaver (Bible Verse): instance id, 0 when none.
+    // A separate flag (not just the id) tracks intent, so a user-closed app
+    // doesn't look like an active screensaver and vice versa.
+    AppInstanceId screensaverAppInstanceId = 0;
+    bool screensaverAppActive = false;
+
+    // Screensaver auto-off: turn off backlight after 30 minutes of screensaver
     static constexpr uint32_t TICK_INTERVAL_MS = 50;
-    static constexpr uint32_t SCREENSAVER_AUTO_OFF_MS = 5 * 60 * 1000;  // 5 minutes
+    static constexpr uint32_t SCREENSAVER_AUTO_OFF_MS = 30 * 60 * 1000;  // 30 minutes
     static constexpr int SCREENSAVER_AUTO_OFF_TICKS = SCREENSAVER_AUTO_OFF_MS / TICK_INTERVAL_MS;
     int screensaverActiveCounter = 0;
     bool backlightOff = false;

Tactility/Private/Tactility/service/webserver/WebServerService.h

@@ -81,8 +81,10 @@ private:
     static error_t handleApiAppsInstall(struct HttpServerRequest* request, void* user_ctx);
     static error_t handleApiWifi(struct HttpServerRequest* request, void* user_ctx);
     static error_t handleApiScreenshot(struct HttpServerRequest* request, void* user_ctx);
-#ifdef ESP_PLATFORM
+    static error_t handleApiSimTouch(struct HttpServerRequest* request, void* user_ctx);
+    static error_t handleSimViewer(struct HttpServerRequest* request, void* user_ctx);
     static error_t handleApiMcp(struct HttpServerRequest* request, void* user_ctx);
+#ifdef ESP_PLATFORM
     static error_t handleApiScreenRaw(struct HttpServerRequest* request, void* user_ctx);
 #endif
 

Tactility/Source/AppStdioWrap.cpp

@@ -1,200 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-
-// Paired with -Wl,--wrap=read/write/close - see Tactility/CMakeLists.txt (POSIX) and the
-// top-level CMakeLists.txt (ESP32) for where that's applied. On a platform where it isn't
-// (currently: macOS, whose linker doesn't support --wrap), these are simply never called - real
-// read()/write()/close() calls go straight through unredirected.
-#include <app/io.h>
-
-#include <sys/types.h>
-
-extern "C" {
-
-ssize_t __wrap_read(int fd, void* buffer, size_t size) {
-    return app_io_read(fd, buffer, size);
-}
-
-ssize_t __wrap_write(int fd, const void* buffer, size_t size) {
-    return app_io_write(fd, buffer, size);
-}
-
-int __wrap_close(int fd) {
-    return app_io_close(fd);
-}
-
-}
-
-// region glibc stdio wraps
-//
-// glibc's printf/fprintf/etc are compiled into libc.so and call an internal, non-exported write()
-// alias - --wrap=write (above) can't reach that call, only calls WE make to the public symbol.
-// These wraps instead redirect calls WE make to printf/fprintf/etc, the same trick as read/write/
-// close above. Newlib (ESP-IDF) doesn't have this gap - its stdio does call the wrappable syscall
-// stubs - so Tactility/CMakeLists.txt only applies the matching -Wl,--wrap= flags on POSIX.
-//
-// Scoped to the printf/getc families only: fread/fwrite take an arbitrary FILE* and are already
-// used sitewide for real file I/O (e.g. File.cpp's readBinaryInternal), so wrapping them would
-// route every such call through this file's stdin/stdout check - a correctness risk for unrelated
-// code that isn't worth taking here. putc/getc are excluded too since glibc defines them as
-// macros, not real calls, so wrapping those symbols wouldn't reliably intercept them.
-
-#if !defined(ESP_PLATFORM) && !defined(__APPLE__)
-
-#include <cstdarg>
-#include <cstdio>
-#include <cstring>
-#include <memory>
-#include <unistd.h>
-
-extern "C" {
-int __real_vfprintf(FILE* stream, const char* format, va_list args);
-int __real_fputs(const char* s, FILE* stream);
-int __real_fputc(int c, FILE* stream);
-int __real_fgetc(FILE* stream);
-char* __real_fgets(char* buffer, int size, FILE* stream);
-}
-
-namespace {
-
-void writeAllToStdout(const void* data, size_t size) {
-    const auto* bytes = static_cast<const char*>(data);
-    size_t remaining = size;
-    while (remaining > 0) {
-        ssize_t written = app_io_write(STDOUT_FILENO, bytes, remaining);
-        if (written <= 0) {
-            break;
-        }
-        bytes += written;
-        remaining -= static_cast<size_t>(written);
-    }
-}
-
-// Formats into stdout via app_io_write() rather than through a FILE*'s own buffering, since that
-// buffering is exactly what glibc's internal write() call sidesteps --wrap for in the first place.
-int formatToStdout(const char* format, va_list args) {
-    char stackBuffer[256];
-    va_list argsForStack;
-    va_copy(argsForStack, args);
-    int needed = vsnprintf(stackBuffer, sizeof(stackBuffer), format, argsForStack);
-    va_end(argsForStack);
-    if (needed < 0) {
-        return needed;
-    }
-    if (static_cast<size_t>(needed) < sizeof(stackBuffer)) {
-        writeAllToStdout(stackBuffer, static_cast<size_t>(needed));
-        return needed;
-    }
-    auto heapBuffer = std::make_unique<char[]>(static_cast<size_t>(needed) + 1);
-    va_list argsForHeap;
-    va_copy(argsForHeap, args);
-    vsnprintf(heapBuffer.get(), static_cast<size_t>(needed) + 1, format, argsForHeap);
-    va_end(argsForHeap);
-    writeAllToStdout(heapBuffer.get(), static_cast<size_t>(needed));
-    return needed;
-}
-
-int readOneFromStdin(char& out) {
-    return static_cast<int>(app_io_read(STDIN_FILENO, &out, 1));
-}
-
-} // namespace
-
-extern "C" {
-
-int __wrap_vprintf(const char* format, va_list args) {
-    return formatToStdout(format, args);
-}
-
-int __wrap_printf(const char* format, ...) {
-    va_list args;
-    va_start(args, format);
-    int result = formatToStdout(format, args);
-    va_end(args);
-    return result;
-}
-
-int __wrap_vfprintf(FILE* stream, const char* format, va_list args) {
-    if (stream == stdout) {
-        return formatToStdout(format, args);
-    }
-    return __real_vfprintf(stream, format, args);
-}
-
-int __wrap_fprintf(FILE* stream, const char* format, ...) {
-    va_list args;
-    va_start(args, format);
-    int result = (stream == stdout) ? formatToStdout(format, args) : __real_vfprintf(stream, format, args);
-    va_end(args);
-    return result;
-}
-
-int __wrap_puts(const char* s) {
-    writeAllToStdout(s, strlen(s));
-    writeAllToStdout("\n", 1);
-    return 0;
-}
-
-int __wrap_fputs(const char* s, FILE* stream) {
-    if (stream == stdout) {
-        writeAllToStdout(s, strlen(s));
-        return 0;
-    }
-    return __real_fputs(s, stream);
-}
-
-int __wrap_putchar(int c) {
-    auto ch = static_cast<char>(c);
-    writeAllToStdout(&ch, 1);
-    return c;
-}
-
-int __wrap_fputc(int c, FILE* stream) {
-    if (stream == stdout) {
-        return __wrap_putchar(c);
-    }
-    return __real_fputc(c, stream);
-}
-
-int __wrap_getchar() {
-    char c;
-    return readOneFromStdin(c) == 1 ? static_cast<unsigned char>(c) : EOF;
-}
-
-int __wrap_fgetc(FILE* stream) {
-    if (stream == stdin) {
-        return __wrap_getchar();
-    }
-    return __real_fgetc(stream);
-}
-
-char* __wrap_fgets(char* buffer, int size, FILE* stream) {
-    if (stream != stdin) {
-        return __real_fgets(buffer, size, stream);
-    }
-    if (size <= 0) {
-        return nullptr;
-    }
-    int i = 0;
-    for (; i < size - 1; ++i) {
-        char c;
-        if (readOneFromStdin(c) != 1) {
-            break;
-        }
-        buffer[i] = c;
-        if (c == '\n') {
-            ++i;
-            break;
-        }
-    }
-    if (i == 0) {
-        return nullptr;
-    }
-    buffer[i] = '\0';
-    return buffer;
-}
-
-}
-
-#endif // !ESP_PLATFORM && !__APPLE__
-
-// endregion

Tactility/Source/Tactility.cpp

@@ -194,6 +194,8 @@ namespace app {
 #if CONFIG_TT_TDECK_WORKAROUND == 1
     namespace keyboardsettings { extern const ::AppManifest manifest; } // T-Deck only for now
 #endif
+#else
+    namespace mcpsettings { extern const ::AppManifest manifest; }
 #endif
 
     namespace trackballsettings { extern const ::AppManifest manifest; } // T-Deck only for now
@@ -252,12 +254,14 @@ static void registerInternalApps() {
     app_manager_add(&app::development::manifest);
     app_manager_add(&app::webserversettings::manifest);
 #ifdef ESP_PLATFORM
+    app_manager_add(&app::mcpsettings::manifest);
     app_manager_add(&app::apwebserver::manifest);
     app_manager_add(&app::crashdiagnostics::manifest);
-    app_manager_add(&app::mcpsettings::manifest);
 #if defined(CONFIG_TT_TDECK_WORKAROUND)
         app_manager_add(&app::keyboardsettings::manifest);
 #endif
+#else
+    app_manager_add(&app::mcpsettings::manifest);
 #endif
 
     if (device_exists_of_type(&TRACKBALL_TYPE)) {

Tactility/Source/app/apphub/AppHubApp.cpp

@@ -339,7 +339,8 @@ extern const ::AppManifest manifest = {
     .id = "tactility.apphub",
     .name = "App Hub",
     .category = APP_CATEGORY_SYSTEM,
-    .location = {APP_LOCATION_MEMORY, reinterpret_cast<void*>(appMain)}
+    .location = {APP_LOCATION_MEMORY, reinterpret_cast<void*>(appMain)},
+    .flags = APP_MANIFEST_FLAG_HIDDEN
 };
 
 } // namespace tt::app::apphub

Tactility/Source/app/btmanage/BtManage.cpp

@@ -245,7 +245,8 @@ extern const ::AppManifest manifest = {
     .id = "tactility.btmanage",
     .name = "Bluetooth",
     .category = APP_CATEGORY_SETTINGS,
-    .location = { APP_LOCATION_MEMORY, reinterpret_cast<void*>(appMain) }
+    .location = { APP_LOCATION_MEMORY, reinterpret_cast<void*>(appMain) },
+    .flags = APP_MANIFEST_FLAG_HIDDEN
 };
 
 } // namespace tt::app::btmanage

Tactility/Source/app/chat/ChatApp.cpp

@@ -228,7 +228,8 @@ extern const ::AppManifest manifest = {
     .id = "tactility.chat",
     .name = "Chat",
     .category = APP_CATEGORY_USER,
-    .location = { APP_LOCATION_MEMORY, reinterpret_cast<void*>(appMain) }
+    .location = { APP_LOCATION_MEMORY, reinterpret_cast<void*>(appMain) },
+    .flags = APP_MANIFEST_FLAG_HIDDEN
 };
 
 } // namespace tt::app::chat

Tactility/Source/app/development/Development.cpp

@@ -230,7 +230,8 @@ extern const ::AppManifest manifest = {
     .id = "tactility.development",
     .name = "Development",
     .category = APP_CATEGORY_SETTINGS,
-    .location = { APP_LOCATION_MEMORY, reinterpret_cast<void*>(appMain) }
+    .location = { APP_LOCATION_MEMORY, reinterpret_cast<void*>(appMain) },
+    .flags = APP_MANIFEST_FLAG_HIDDEN
 };
 
 } // namespace

Tactility/Source/app/display/Display.cpp

@@ -42,6 +42,10 @@ struct Context {
     lv_obj_t* timeoutSwitch = nullptr;
     lv_obj_t* timeoutDropdown = nullptr;
     lv_obj_t* screensaverDropdown = nullptr;
+    lv_obj_t* nightDimSwitch = nullptr;
+    lv_obj_t* nightDimStartDropdown = nullptr;
+    lv_obj_t* nightDimEndDropdown = nullptr;
+    lv_obj_t* nightDimDutySlider = nullptr;
 };
 
 
@@ -131,8 +135,8 @@ void onTimeoutChanged(lv_event_t* event) {
     auto* ctx = static_cast<Context*>(lv_event_get_user_data(event));
     auto* dropdown = static_cast<lv_obj_t*>(lv_event_get_target(event));
     uint32_t idx = lv_dropdown_get_selected(dropdown);
-    // Map dropdown index to ms: 0=15s,1=30s,2=1m,3=2m,4=5m,5=Never
-    static const uint32_t values_ms[] = {15000, 30000, 60000, 120000, 300000, 0};
+    // Map dropdown index to ms: 0=15s,1=30s,2=1m,3=2m,4=5m,5=15m,6=30m,7=Never
+    static const uint32_t values_ms[] = {15000, 30000, 60000, 120000, 300000, 900000, 1800000, 0};
     if (idx < (sizeof(values_ms)/sizeof(values_ms[0]))) {
         ctx->displaySettings.backlightTimeoutMs = values_ms[idx];
         ctx->displaySettingsUpdated = true;
@@ -154,6 +158,82 @@ void onScreensaverChanged(lv_event_t* event) {
     }
 }
 
+static void setNightDimControlsEnabled(Context* ctx, bool enabled) {
+    if (ctx->nightDimStartDropdown != nullptr) {
+        if (enabled) {
+            lv_obj_clear_state(ctx->nightDimStartDropdown, LV_STATE_DISABLED);
+        } else {
+            lv_obj_add_state(ctx->nightDimStartDropdown, LV_STATE_DISABLED);
+        }
+    }
+    if (ctx->nightDimEndDropdown != nullptr) {
+        if (enabled) {
+            lv_obj_clear_state(ctx->nightDimEndDropdown, LV_STATE_DISABLED);
+        } else {
+            lv_obj_add_state(ctx->nightDimEndDropdown, LV_STATE_DISABLED);
+        }
+    }
+    if (ctx->nightDimDutySlider != nullptr) {
+        if (enabled) {
+            lv_obj_clear_state(ctx->nightDimDutySlider, LV_STATE_DISABLED);
+        } else {
+            lv_obj_add_state(ctx->nightDimDutySlider, LV_STATE_DISABLED);
+        }
+    }
+}
+
+static const char* hourOptions() {
+    // 00..23, one per line
+    static const char* options =
+        "00\n01\n02\n03\n04\n05\n06\n07\n08\n09\n10\n11\n"
+        "12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23";
+    return options;
+}
+
+void onNightDimSwitch(lv_event_t* event) {
+    auto* ctx = static_cast<Context*>(lv_event_get_user_data(event));
+    auto* sw = static_cast<lv_obj_t*>(lv_event_get_target(event));
+    bool enabled = lv_obj_has_state(sw, LV_STATE_CHECKED);
+    ctx->displaySettings.nightDimEnabled = enabled;
+    ctx->displaySettingsUpdated = true;
+    setNightDimControlsEnabled(ctx, enabled);
+}
+
+void onNightDimStartChanged(lv_event_t* event) {
+    auto* ctx = static_cast<Context*>(lv_event_get_user_data(event));
+    auto* dropdown = static_cast<lv_obj_t*>(lv_event_get_target(event));
+    uint32_t idx = lv_dropdown_get_selected(dropdown);
+    if (idx > 23) {
+        return;
+    }
+    ctx->displaySettings.nightDimStartHour = static_cast<uint8_t>(idx);
+    ctx->displaySettingsUpdated = true;
+}
+
+void onNightDimEndChanged(lv_event_t* event) {
+    auto* ctx = static_cast<Context*>(lv_event_get_user_data(event));
+    auto* dropdown = static_cast<lv_obj_t*>(lv_event_get_target(event));
+    uint32_t idx = lv_dropdown_get_selected(dropdown);
+    if (idx > 23) {
+        return;
+    }
+    ctx->displaySettings.nightDimEndHour = static_cast<uint8_t>(idx);
+    ctx->displaySettingsUpdated = true;
+}
+
+void onNightDimDutyChanged(lv_event_t* event) {
+    auto* ctx = static_cast<Context*>(lv_event_get_user_data(event));
+    auto* slider = static_cast<lv_obj_t*>(lv_event_get_target(event));
+    int32_t value = lv_slider_get_value(slider);
+    if (value < 0) {
+        value = 0;
+    } else if (value > 255) {
+        value = 255;
+    }
+    ctx->displaySettings.nightDimDuty = static_cast<uint8_t>(value);
+    ctx->displaySettingsUpdated = true;
+}
+
 void createWidgets(lv_obj_t* parent, void* userData) {
     auto* ctx = static_cast<Context*>(userData);
 
@@ -273,7 +353,7 @@ void createWidgets(lv_obj_t* parent, void* userData) {
         lv_obj_align(timeout_value_label, LV_ALIGN_LEFT_MID, 0, 0);
 
         ctx->timeoutDropdown = lv_dropdown_create(timeout_select_wrapper);
-        lv_dropdown_set_options(ctx->timeoutDropdown, "15 seconds\n30 seconds\n1 minute\n2 minutes\n5 minutes\nNever");
+        lv_dropdown_set_options(ctx->timeoutDropdown, "15 seconds\n30 seconds\n1 minute\n2 minutes\n5 minutes\n15 minutes\n30 minutes\nNever");
         lv_obj_align(ctx->timeoutDropdown, LV_ALIGN_RIGHT_MID, 0, 0);
         lv_obj_add_event_cb(ctx->timeoutDropdown, onTimeoutChanged, LV_EVENT_VALUE_CHANGED, ctx);
         // Initialize dropdown selection from settings
@@ -288,8 +368,12 @@ void createWidgets(lv_obj_t* parent, void* userData) {
             idx = 3;
         else if (ms == 300000)
             idx = 4;
-        else if (ms == 0)
+        else if (ms == 900000)
             idx = 5;
+        else if (ms == 1800000)
+            idx = 6;
+        else if (ms == 0)
+            idx = 7;
         lv_dropdown_set_selected(ctx->timeoutDropdown, idx);
         if (!ctx->displaySettings.backlightTimeoutEnabled) {
             lv_obj_add_state(ctx->timeoutDropdown, LV_STATE_DISABLED);
@@ -307,13 +391,78 @@ void createWidgets(lv_obj_t* parent, void* userData) {
 
         ctx->screensaverDropdown = lv_dropdown_create(screensaver_wrapper);
         // Note: order correlates with settings::display::ScreensaverType enum order
-    lv_dropdown_set_options(ctx->screensaverDropdown, "None\nBouncing Balls\nMystify\nMatrix Rain\nStackChan\nMCP Screen");
+    lv_dropdown_set_options(ctx->screensaverDropdown, "None\nBouncing Balls\nMystify\nMatrix Rain\nStackChan\nMCP Screen\nBible Verse");
         lv_obj_align(ctx->screensaverDropdown, LV_ALIGN_RIGHT_MID, 0, 0);
         lv_obj_add_event_cb(ctx->screensaverDropdown, onScreensaverChanged, LV_EVENT_VALUE_CHANGED, ctx);
         lv_dropdown_set_selected(ctx->screensaverDropdown, static_cast<uint16_t>(ctx->displaySettings.screensaverType));
         if (!ctx->displaySettings.backlightTimeoutEnabled) {
             lv_obj_add_state(ctx->screensaverDropdown, LV_STATE_DISABLED);
         }
+
+        // Night dim: dim the backlight while the screensaver is up, during a time window
+        auto* night_dim_wrapper = lv_obj_create(main_wrapper);
+        lv_obj_set_size(night_dim_wrapper, LV_PCT(100), LV_SIZE_CONTENT);
+        lv_obj_set_style_pad_all(night_dim_wrapper, 0, LV_STATE_DEFAULT);
+        lv_obj_set_style_border_width(night_dim_wrapper, 0, LV_STATE_DEFAULT);
+
+        auto* night_dim_label = lv_label_create(night_dim_wrapper);
+        lv_label_set_text(night_dim_label, "Night dim");
+        lv_obj_align(night_dim_label, LV_ALIGN_LEFT_MID, 0, 0);
+
+        ctx->nightDimSwitch = lv_switch_create(night_dim_wrapper);
+        if (ctx->displaySettings.nightDimEnabled) {
+            lv_obj_add_state(ctx->nightDimSwitch, LV_STATE_CHECKED);
+        }
+        lv_obj_align(ctx->nightDimSwitch, LV_ALIGN_RIGHT_MID, 0, 0);
+        lv_obj_add_event_cb(ctx->nightDimSwitch, onNightDimSwitch, LV_EVENT_VALUE_CHANGED, ctx);
+
+        auto* night_dim_start_wrapper = lv_obj_create(main_wrapper);
+        lv_obj_set_size(night_dim_start_wrapper, LV_PCT(100), LV_SIZE_CONTENT);
+        lv_obj_set_style_pad_all(night_dim_start_wrapper, 0, LV_STATE_DEFAULT);
+        lv_obj_set_style_border_width(night_dim_start_wrapper, 0, LV_STATE_DEFAULT);
+
+        auto* night_dim_start_label = lv_label_create(night_dim_start_wrapper);
+        lv_label_set_text(night_dim_start_label, "Dim from");
+        lv_obj_align(night_dim_start_label, LV_ALIGN_LEFT_MID, 0, 0);
+
+        ctx->nightDimStartDropdown = lv_dropdown_create(night_dim_start_wrapper);
+        lv_dropdown_set_options(ctx->nightDimStartDropdown, hourOptions());
+        lv_obj_align(ctx->nightDimStartDropdown, LV_ALIGN_RIGHT_MID, 0, 0);
+        lv_obj_add_event_cb(ctx->nightDimStartDropdown, onNightDimStartChanged, LV_EVENT_VALUE_CHANGED, ctx);
+        lv_dropdown_set_selected(ctx->nightDimStartDropdown, ctx->displaySettings.nightDimStartHour > 23 ? 0 : ctx->displaySettings.nightDimStartHour);
+
+        auto* night_dim_end_wrapper = lv_obj_create(main_wrapper);
+        lv_obj_set_size(night_dim_end_wrapper, LV_PCT(100), LV_SIZE_CONTENT);
+        lv_obj_set_style_pad_all(night_dim_end_wrapper, 0, LV_STATE_DEFAULT);
+        lv_obj_set_style_border_width(night_dim_end_wrapper, 0, LV_STATE_DEFAULT);
+
+        auto* night_dim_end_label = lv_label_create(night_dim_end_wrapper);
+        lv_label_set_text(night_dim_end_label, "Dim until");
+        lv_obj_align(night_dim_end_label, LV_ALIGN_LEFT_MID, 0, 0);
+
+        ctx->nightDimEndDropdown = lv_dropdown_create(night_dim_end_wrapper);
+        lv_dropdown_set_options(ctx->nightDimEndDropdown, hourOptions());
+        lv_obj_align(ctx->nightDimEndDropdown, LV_ALIGN_RIGHT_MID, 0, 0);
+        lv_obj_add_event_cb(ctx->nightDimEndDropdown, onNightDimEndChanged, LV_EVENT_VALUE_CHANGED, ctx);
+        lv_dropdown_set_selected(ctx->nightDimEndDropdown, ctx->displaySettings.nightDimEndHour > 23 ? 0 : ctx->displaySettings.nightDimEndHour);
+
+        auto* night_dim_duty_wrapper = lv_obj_create(main_wrapper);
+        lv_obj_set_size(night_dim_duty_wrapper, LV_PCT(100), LV_SIZE_CONTENT);
+        lv_obj_set_style_pad_all(night_dim_duty_wrapper, 0, LV_STATE_DEFAULT);
+        lv_obj_set_style_border_width(night_dim_duty_wrapper, 0, LV_STATE_DEFAULT);
+
+        auto* night_dim_duty_label = lv_label_create(night_dim_duty_wrapper);
+        lv_label_set_text(night_dim_duty_label, "Dim brightness");
+        lv_obj_align(night_dim_duty_label, LV_ALIGN_LEFT_MID, 0, 0);
+
+        ctx->nightDimDutySlider = lv_slider_create(night_dim_duty_wrapper);
+        lv_obj_set_width(ctx->nightDimDutySlider, LV_PCT(50));
+        lv_obj_align(ctx->nightDimDutySlider, LV_ALIGN_RIGHT_MID, 0, 0);
+        lv_slider_set_range(ctx->nightDimDutySlider, 0, 255);
+        lv_slider_set_value(ctx->nightDimDutySlider, ctx->displaySettings.nightDimDuty, LV_ANIM_OFF);
+        lv_obj_add_event_cb(ctx->nightDimDutySlider, onNightDimDutyChanged, LV_EVENT_VALUE_CHANGED, ctx);
+
+        setNightDimControlsEnabled(ctx, ctx->displaySettings.nightDimEnabled);
     }
 }
 

Tactility/Source/app/files/SupportedFiles.cpp

@@ -26,4 +26,12 @@ bool isSupportedTextFile(const std::string& filename) {
         filename_lower.ends_with(".properties");
 }
 
+bool isSupportedAudioFile(const std::string& filename) {
+    std::string filename_lower = string::lowercase(filename);
+    return filename_lower.ends_with(".mp3") ||
+        filename_lower.ends_with(".wav") ||
+        filename_lower.ends_with(".ogg") ||
+        filename_lower.ends_with(".flac");
+}
+
 } // namespace tt::app::filebrowser

Tactility/Source/app/files/View.cpp

@@ -1,6 +1,7 @@
 #include <app/event.h>
 #include <app/execute.h>
 #include <app/install.h>
+#include <app/start.h>
 #include <app/stream.h>
 
 #include <lvgl/lvgl.h>
@@ -204,6 +205,15 @@ void View::viewFile(const std::string& path, const std::string& filename) {
             // Remove forward slash, because we need a relative path
             notes::start(file_path.substr(1));
         }
+    } else if (isSupportedAudioFile(filename)) {
+        // External MP3 player reads argv as key=value pairs (see
+        // CurrentAppCompat tt_app_start_with_bundle): file=<path>
+        std::string file_arg = "file=" + file_path;
+        const char* argv[] = { file_arg.c_str() };
+        uint32_t instance_id = 0;
+        if (app_start("one.tactility.mp3player", 1, argv, &instance_id) != ERROR_NONE) {
+            LOG_W(TAG, "Failed to start MP3 player for %s", file_path.c_str());
+        }
     } else if (isExecutablePath(file_path)) {
         runFile(file_path);
     } else {

Tactility/Source/app/fileselection/FileSelection.cpp

@@ -85,7 +85,7 @@ int32_t appMain(int argc, char* argv[]) {
 
     if (ctx.resultCode == 0) {
         // The parent captures this via an AppStream bound to our stdout (see startWithMode()) -
-        // see AppStdioWrap.cpp for how printf() itself gets routed there on POSIX.
+        // see Modules/app-module/source/stdio_wrap.cpp for how printf() itself gets routed there on POSIX.
         LOG_I(TAG, "Result: %s", ctx.resultPath.c_str());
         printf("%s", ctx.resultPath.c_str());
     }

Tactility/Source/app/i2cscanner/I2cScanner.cpp

@@ -426,7 +426,8 @@ extern const ::AppManifest manifest = {
     .id = "tactility.i2cscanner",
     .name = "I2C Scanner",
     .category = APP_CATEGORY_SYSTEM,
-    .location = { APP_LOCATION_MEMORY, reinterpret_cast<void*>(appMain) }
+    .location = { APP_LOCATION_MEMORY, reinterpret_cast<void*>(appMain) },
+    .flags = APP_MANIFEST_FLAG_HIDDEN
 };
 
 uint32_t start() {

Tactility/Source/app/inputdialog/InputDialog.cpp

@@ -138,7 +138,7 @@ int32_t appMain(int argc, char* argv[]) {
 
     if (ctx.resultCode == 0) {
         // The caller captures this via an AppStream bound to our stdout (see start()); see
-        // AppStdioWrap.cpp for how printf() itself gets routed there on POSIX.
+        // Modules/app-module/source/stdio_wrap.cpp for how printf() itself gets routed there on POSIX.
         printf("%s", ctx.resultText.c_str());
     }
     return ctx.resultCode;

Tactility/Source/app/launcher/Launcher.cpp

@@ -3,6 +3,7 @@
 #include <app/manifest.h>
 #include <app/scheduler.h>
 #include <app/start.h>
+
 #include <Tactility/DeprecatedPaths.h>
 #include <Tactility/MountPoints.h>
 #include <Tactility/Tactility.h>

Tactility/Source/app/localesettings/LocaleSettings.cpp

@@ -182,7 +182,8 @@ extern const ::AppManifest manifest = {
     .id = "tactility.localesettings",
     .name = "Region & Language",
     .category = APP_CATEGORY_SETTINGS,
-    .location = { APP_LOCATION_MEMORY, reinterpret_cast<void*>(appMain) }
+    .location = { APP_LOCATION_MEMORY, reinterpret_cast<void*>(appMain) },
+    .flags = APP_MANIFEST_FLAG_HIDDEN
 };
 
 } // namespace tt::app::localesettings

Tactility/Source/app/mcpsettings/McpSettingsApp.cpp

@@ -13,7 +13,7 @@
 #include <tactility/check.h>
 #include <tactility/log.h>
 #include <esp_netif.h>
-#include <lvgl.h>
+
 #include <string>
 
 namespace tt::app::mcpsettings {
@@ -24,7 +24,6 @@ struct Context {
     uint32_t appInstanceId;
     settings::mcp::McpSettings mcpSettings;
     settings::webserver::WebServerSettings wsSettings;
-    bool updated = false;
     lv_obj_t* switchMcpEnabled = nullptr;
     lv_obj_t* labelUrlValue = nullptr;
 };
@@ -59,7 +58,7 @@ void onMcpEnabledSwitch(lv_event_t* event) {
     auto* ctx = static_cast<Context*>(lv_event_get_user_data(event));
     const bool enabled = lv_obj_has_state(ctx->switchMcpEnabled, LV_STATE_CHECKED);
     getMainDispatcher().dispatch([ctx, enabled] {
-        ctx->mcpSettings.mcpEnabled = enabled; ctx->updated = true;
+        ctx->mcpSettings.mcpEnabled = enabled;
         lvgl_lock(); updateUrlDisplay(ctx); lvgl_unlock();
         if (!settings::mcp::save(ctx->mcpSettings)) LOG_W(TAG, "Failed to persist MCP settings");
         service::webserver::getPubsub()->publish(service::webserver::WebServerEvent::WebServerSettingsChanged);
@@ -93,6 +92,6 @@ int32_t appMain(int, char**) {
     window_manager_remove(window); check(app_event_unsubscribe(&sub) == ERROR_NONE); task_event_group_destruct(&group); return 0;
 }
 }
-extern const ::AppManifest manifest = { .id = "McpSettings", .name = "MCP Screen", .category = APP_CATEGORY_SETTINGS, .location = { APP_LOCATION_MEMORY, reinterpret_cast<void*>(appMain) }, .flags = 0, .stack = { .depth = 8192, .desired_memory_capability = 0 } };
+extern const ::AppManifest manifest = { .id = "McpSettings", .name = "MCP Screen", .category = APP_CATEGORY_SETTINGS, .location = { APP_LOCATION_MEMORY, reinterpret_cast<void*>(appMain) }, .flags = APP_MANIFEST_FLAG_HIDDEN, .stack = { .depth = 8192, .desired_memory_capability = 0 } };
 }
 #endif

Tactility/Source/app/mcpsettings/McpSettingsSimulatorApp.cpp

@@ -0,0 +1,66 @@
+#ifndef ESP_PLATFORM
+
+#include <app/event.h>
+#include <app/manifest.h>
+#include <app/scheduler.h>
+#include <lvgl/lvgl.h>
+#include <lvgl_window_manager/window_manager.h>
+
+namespace tt::app::mcpsettings {
+struct Context { AppInstanceId instanceId; };
+
+void createMcpInfo(lv_obj_t* parent, void* userData) {
+    auto* context = static_cast<Context*>(userData);
+    lv_obj_t* title = lv_label_create(parent);
+    lv_label_set_text(title, "MCP Settings");
+    lv_obj_align(title, LV_ALIGN_TOP_MID, 0, 18);
+
+    lv_obj_t* info = lv_label_create(parent);
+    lv_label_set_text(info,
+        "MCP is available while the simulator web server is running.\n\n"
+        "Endpoint: POST /api/mcp\n"
+        "JSON-RPC methods: tools/list, tools/call\n\n"
+        "Simulator tools: get_capabilities, clear_screen, draw_text, list_apps, run_app\n\n"
+        "Open the simulator dashboard/API at http://127.0.0.1/api/sysinfo.");
+    lv_label_set_long_mode(info, LV_LABEL_LONG_WRAP);
+    lv_obj_set_width(info, LV_PCT(90));
+    lv_obj_align(info, LV_ALIGN_CENTER, 0, 8);
+
+    (void)context;
+}
+
+int32_t appMain(int, char**) {
+    Context context{app_scheduler_current_app_id()};
+    TaskEventGroup group{};
+    task_event_group_construct(&group);
+    AppEventSubscription subscription{};
+    if (app_event_subscribe(&subscription, &group) != ERROR_NONE) {
+        task_event_group_destruct(&group);
+        return -1;
+    }
+    auto window = window_manager_create(context.instanceId, createMcpInfo, &context);
+    bool close = false;
+    while (!close) {
+        task_event_group_wait_any(&group, nullptr, portMAX_DELAY);
+        AppEvent event{};
+        while (app_event_poll(&subscription, &event) == ERROR_NONE) {
+            if (event.type == APP_EVENT_CLOSE) { close = true; break; }
+        }
+    }
+    window_manager_remove(window);
+    app_event_unsubscribe(&subscription);
+    task_event_group_destruct(&group);
+    return 0;
+}
+
+extern const AppManifest manifest = {
+    .id = "McpSettings",
+    .name = "MCP Settings",
+    .category = APP_CATEGORY_SETTINGS,
+    .location = {APP_LOCATION_MEMORY, reinterpret_cast<void*>(appMain)},
+    .flags = 0,
+    .stack = {.depth = 8192, .desired_memory_capability = 0}
+};
+}
+
+#endif

Tactility/Source/app/notes/Notes.cpp

@@ -276,7 +276,8 @@ extern const ::AppManifest manifest = {
     .id = "tactility.notes",
     .name = "Notes",
     .category = APP_CATEGORY_USER,
-    .location = { APP_LOCATION_MEMORY, reinterpret_cast<void*>(appMain) }
+    .location = { APP_LOCATION_MEMORY, reinterpret_cast<void*>(appMain) },
+    .flags = APP_MANIFEST_FLAG_HIDDEN
 };
 
 } // namespace tt::app::notes

Tactility/Source/app/power/Power.cpp

@@ -278,7 +278,8 @@ extern const ::AppManifest manifest = {
     .id = "tactility.power",
     .name = "Power",
     .category = APP_CATEGORY_SETTINGS,
-    .location = { APP_LOCATION_MEMORY, reinterpret_cast<void*>(appMain) }
+    .location = { APP_LOCATION_MEMORY, reinterpret_cast<void*>(appMain) },
+    .flags = APP_MANIFEST_FLAG_HIDDEN
 };
 
 } // namespace

Tactility/Source/app/screenshot/Screenshot.cpp

@@ -290,7 +290,8 @@ extern const ::AppManifest manifest = {
     .id = "tactility.screenshot",
     .name = "Screenshot",
     .category = APP_CATEGORY_SYSTEM,
-    .location = { APP_LOCATION_MEMORY, reinterpret_cast<void*>(appMain) }
+    .location = { APP_LOCATION_MEMORY, reinterpret_cast<void*>(appMain) },
+    .flags = APP_MANIFEST_FLAG_HIDDEN
 };
 
 } // namespace

Tactility/Source/app/systeminfo/SystemInfo.cpp

@@ -457,7 +457,8 @@ extern const ::AppManifest manifest = {
     .id = "tactility.systeminfo",
     .name = "System Info",
     .category = APP_CATEGORY_SYSTEM,
-    .location = { APP_LOCATION_MEMORY, reinterpret_cast<void*>(appMain) }
+    .location = { APP_LOCATION_MEMORY, reinterpret_cast<void*>(appMain) },
+    .flags = APP_MANIFEST_FLAG_HIDDEN
 };
 
 } // namespace

Tactility/Source/app/timedatesettings/TimeDateSettings.cpp

@@ -215,7 +215,8 @@ extern const ::AppManifest manifest = {
     .id = "tactility.timedatesettings",
     .name = "Time & Date",
     .category = APP_CATEGORY_SETTINGS,
-    .location = { APP_LOCATION_MEMORY, reinterpret_cast<void*>(appMain) }
+    .location = { APP_LOCATION_MEMORY, reinterpret_cast<void*>(appMain) },
+    .flags = APP_MANIFEST_FLAG_HIDDEN
 };
 
 } // namespace tt::app::timedatesettings

Tactility/Source/app/webserversettings/WebServerSettings.cpp

@@ -424,7 +424,8 @@ extern const ::AppManifest manifest = {
     .id = "tactility.webserversettings",
     .name = "Web Server",
     .category = APP_CATEGORY_SYSTEM,
-    .location = { APP_LOCATION_MEMORY, reinterpret_cast<void*>(appMain) }
+    .location = { APP_LOCATION_MEMORY, reinterpret_cast<void*>(appMain) },
+    .flags = APP_MANIFEST_FLAG_HIDDEN
 };
 
 }

Tactility/Source/mcp/McpSystem.cpp

@@ -415,7 +415,7 @@ std::string getScreenshotPbmBase64() {
     size_t total_size = (size_t)header_length + payload_size;
     size_t base64_len = 0;
     mbedtls_base64_encode(nullptr, 0, &base64_len, pbm, total_size);
-
+    
     std::string encoded(base64_len + 1, '\0');
     size_t actual_len = 0;
     mbedtls_base64_encode(reinterpret_cast<unsigned char*>(encoded.data()),
@@ -1252,10 +1252,10 @@ bool setLedColor(int r, int g, int b, const std::string& mode, std::string& erro
 bool getSensors(double& temp_c, double& hum_pct, std::string& imu_json, std::string& error) {
     temp_c = 22.5;
     hum_pct = 50.0;
-
+    
     cJSON* imu = cJSON_CreateObject();
     bool has_imu = false;
-
+    
     struct Device* bmi = nullptr;
     device_get_by_name("bmi270", &bmi);
     if (bmi != nullptr && bmi270_read != nullptr) {
@@ -1273,7 +1273,7 @@ bool getSensors(double& temp_c, double& hum_pct, std::string& imu_json, std::str
     if (bmi != nullptr) {
         device_put(bmi);
     }
-
+    
     if (!has_imu) {
         struct Device* mpu = nullptr;
         device_get_by_name("mpu6886", &mpu);
@@ -1293,7 +1293,7 @@ bool getSensors(double& temp_c, double& hum_pct, std::string& imu_json, std::str
             device_put(mpu);
         }
     }
-
+    
     if (!has_imu) {
         struct Device* qmi = nullptr;
         device_get_by_name("qmi8658", &qmi);
@@ -1313,7 +1313,7 @@ bool getSensors(double& temp_c, double& hum_pct, std::string& imu_json, std::str
             device_put(qmi);
         }
     }
-
+    
     if (has_imu) {
         char* printed = cJSON_PrintUnformatted(imu);
         if (printed != nullptr) {
@@ -1333,7 +1333,7 @@ bool scanBleDevices(int duration_ms, std::string& devices_json, std::string& err
         error = "BLE device not found";
         return false;
     }
-
+    
     auto radio_state = bluetooth::getRadioState();
     bool originally_off = (radio_state == bluetooth::RadioState::Off);
     if (radio_state != bluetooth::RadioState::On) {
@@ -1350,15 +1350,15 @@ bool scanBleDevices(int duration_ms, std::string& devices_json, std::string& err
             return false;
         }
     }
-
+    
     LOG_I(TAG, "Starting BLE scan for %d ms", duration_ms);
     bluetooth_scan_start(dev);
     vTaskDelay(pdMS_TO_TICKS(duration_ms));
     bluetooth_scan_stop(dev);
     vTaskDelay(pdMS_TO_TICKS(100));
-
+    
     std::vector<bluetooth::PeerRecord> peers = bluetooth::getScanResults();
-
+    
     cJSON* root = cJSON_CreateObject();
     cJSON* dev_array = cJSON_AddArrayToObject(root, "devices");
     for (const auto& peer : peers) {
@@ -1374,7 +1374,7 @@ bool scanBleDevices(int duration_ms, std::string& devices_json, std::string& err
         cJSON_AddBoolToObject(item, "connected", peer.connected);
         cJSON_AddItemToArray(dev_array, item);
     }
-
+    
     char* printed = cJSON_PrintUnformatted(root);
     if (printed != nullptr) {
         devices_json = printed;
@@ -1383,7 +1383,7 @@ bool scanBleDevices(int duration_ms, std::string& devices_json, std::string& err
         devices_json = "{\"devices\":[]}";
     }
     cJSON_Delete(root);
-
+    
     if (originally_off) {
         LOG_I(TAG, "Restoring BLE radio state to off");
         bluetooth_set_radio_enabled(dev, false);
@@ -1509,18 +1509,18 @@ bool downloadSdFile(const std::string& url, const std::string& filename, std::st
 
 static void mcp_video_stream_task(void* pvParameters) {
     auto& state = getState();
-
+    
     int mono_server_fd = -1;
     int color_server_fd = -1;
     int mono_client_fd = -1;
     int color_client_fd = -1;
-
+    
     uint8_t* mono_buffer = (uint8_t*)heap_caps_malloc(15000, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
     if (mono_buffer == nullptr) mono_buffer = (uint8_t*)heap_caps_malloc(15000, MALLOC_CAP_8BIT);
-
+    
     uint8_t* color_buffer = (uint8_t*)heap_caps_malloc(153600, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
     if (color_buffer == nullptr) color_buffer = (uint8_t*)heap_caps_malloc(153600, MALLOC_CAP_8BIT);
-
+    
     if (mono_buffer == nullptr || color_buffer == nullptr) {
         LOG_E(TAG, "Failed to allocate video stream buffers");
         if (mono_buffer) heap_caps_free(mono_buffer);
@@ -1529,7 +1529,7 @@ static void mcp_video_stream_task(void* pvParameters) {
         vTaskDelete(nullptr);
         return;
     }
-
+    
     // Create Mono TCP Server Socket
     mono_server_fd = socket(AF_INET, SOCK_STREAM, 0);
     if (mono_server_fd >= 0) {
@@ -1549,7 +1549,7 @@ static void mcp_video_stream_task(void* pvParameters) {
             mono_server_fd = -1;
         }
     }
-
+    
     // Create Color TCP Server Socket
     color_server_fd = socket(AF_INET, SOCK_STREAM, 0);
     if (color_server_fd >= 0) {
@@ -1569,29 +1569,29 @@ static void mcp_video_stream_task(void* pvParameters) {
             color_server_fd = -1;
         }
     }
-
+    
     uint32_t mono_received = 0;
     uint32_t color_header_received = 0;
     uint32_t color_payload_received = 0;
     uint8_t color_header[16];
-
+    
     uint16_t color_x = 0, color_y = 0, color_w = 0, color_h = 0;
     uint32_t color_payload_len = 0;
-
+    
     uint32_t last_packet_time = xTaskGetTickCount();
     uint32_t fps_start_time = xTaskGetTickCount();
     uint32_t fps_frame_count = 0;
-
+    
     while (state.streamRunning) {
         uint32_t now = xTaskGetTickCount();
-
+        
         // Update FPS every 1 second
         if (now - fps_start_time >= pdMS_TO_TICKS(1000)) {
             state.lastFps = (double)fps_frame_count * 1000.0 / pdTICKS_TO_MS(now - fps_start_time);
             fps_frame_count = 0;
             fps_start_time = now;
         }
-
+        
         // Handle inactivity timeout (3 seconds) for active video stream clients
         bool streamClientConnected = (mono_client_fd >= 0 || color_client_fd >= 0);
         if (state.overrideActive && streamClientConnected && (now - last_packet_time) > pdMS_TO_TICKS(3000)) {
@@ -1610,7 +1610,7 @@ static void mcp_video_stream_task(void* pvParameters) {
                 idleService->stopScreensaver();
             }
         }
-
+        
         // 1. Accept Mono client
         if (mono_server_fd >= 0 && mono_client_fd < 0) {
             struct sockaddr_in client_addr;
@@ -1624,7 +1624,7 @@ static void mcp_video_stream_task(void* pvParameters) {
                 LOG_I(TAG, "Mono TCP Stream client connected");
             }
         }
-
+        
         // 2. Read Mono client data
         if (mono_client_fd >= 0) {
             int remaining = 15000 - mono_received;
@@ -1633,7 +1633,7 @@ static void mcp_video_stream_task(void* pvParameters) {
                 mono_received += n;
                 last_packet_time = now;
                 state.tcpBytesReceived += n;
-
+                
                 if (mono_received == 15000) {
                     uint32_t draw_start = xTaskGetTickCount();
                     if (ensureOverrideScreen()) {
@@ -1643,19 +1643,19 @@ static void mcp_video_stream_task(void* pvParameters) {
                                 for (size_t i = 0; i < pixel_count; ++i) {
                                     state.framebuffer[i] = 0xFFFF; // Fill canvas with white
                                 }
-
+                                
                                 int x_off = (state.drawWidth - 200) / 2;
                                 int y_off = (state.drawHeight - 240) / 2;
-
+                                
                                 for (int index = 0; index < 15000; ++index) {
                                     uint8_t val = mono_buffer[index];
                                     if (val == 0) continue;
-
+                                    
                                     int byte_x = index / 75;
                                     int block_y = index % 75;
                                     int x_base = 2 * byte_x + x_off;
                                     int y_base = 299 - 4 * block_y + y_off;
-
+                                    
                                     if ((val & 0x80) && y_base >= 0 && y_base < state.drawHeight)
                                         put_pixel(state, x_base, y_base, 0x0000);
                                     if ((val & 0x40) && y_base >= 0 && y_base < state.drawHeight)
@@ -1682,7 +1682,7 @@ static void mcp_video_stream_task(void* pvParameters) {
                     state.lastDrawMs = pdTICKS_TO_MS(xTaskGetTickCount() - draw_start);
                     state.framesDrawn++;
                     fps_frame_count++;
-
+                    
                     mono_received = 0;
                 }
             } else if (n == 0 || (n < 0 && errno != EAGAIN && errno != EWOULDBLOCK)) {
@@ -1699,7 +1699,7 @@ static void mcp_video_stream_task(void* pvParameters) {
                 }
             }
         }
-
+        
         // 3. Accept Color client
         if (color_server_fd >= 0 && color_client_fd < 0) {
             struct sockaddr_in client_addr;
@@ -1714,7 +1714,7 @@ static void mcp_video_stream_task(void* pvParameters) {
                 LOG_I(TAG, "Color TCP Stream client connected");
             }
         }
-
+        
         // 4. Read Color client data
         if (color_client_fd >= 0) {
             if (color_header_received < 16) {
@@ -1724,7 +1724,7 @@ static void mcp_video_stream_task(void* pvParameters) {
                     color_header_received += n;
                     last_packet_time = now;
                     state.tcpBytesReceived += n;
-
+                    
                     if (color_header_received == 16) {
                         if (memcmp(color_header, "RAW\x01", 4) != 0) {
                             LOG_W(TAG, "Invalid Color Stream magic! Disconnecting client.");
@@ -1740,7 +1740,7 @@ static void mcp_video_stream_task(void* pvParameters) {
                                                 ((uint32_t)color_header[14] << 8) |
                                                 color_header[15];
                             color_payload_received = 0;
-
+                            
                             if (color_payload_len > 153600) {
                                 LOG_W(TAG, "Color stream payload too large (%u bytes). Disconnecting.", color_payload_len);
                                 close(color_client_fd);
@@ -1761,7 +1761,7 @@ static void mcp_video_stream_task(void* pvParameters) {
                     }
                 }
             }
-
+            
             if (color_client_fd >= 0 && color_header_received == 16 && color_payload_len > 0) {
                 int remaining = color_payload_len - color_payload_received;
                 int n = recv(color_client_fd, color_buffer + color_payload_received, remaining, 0);
@@ -1769,15 +1769,15 @@ static void mcp_video_stream_task(void* pvParameters) {
                     color_payload_received += n;
                     last_packet_time = now;
                     state.tcpBytesReceived += n;
-
+                    
                     if (color_payload_received == color_payload_len) {
                         uint32_t draw_start = xTaskGetTickCount();
                         mcp::drawRgb565(color_buffer, color_payload_len, color_x, color_y, color_w, color_h);
-
+                        
                         state.lastDrawMs = pdTICKS_TO_MS(xTaskGetTickCount() - draw_start);
                         state.framesDrawn++;
                         fps_frame_count++;
-
+                        
                         color_header_received = 0;
                         color_payload_len = 0;
                         color_payload_received = 0;
@@ -1796,7 +1796,7 @@ static void mcp_video_stream_task(void* pvParameters) {
                 }
             }
         }
-
+        
         // Yield: longer delay when no client connected to save CPU
         // RLCD ST7305 SPI is slow and shared - don't hog LVGL lock (fix freeze)
         if (mono_client_fd < 0 && color_client_fd < 0) {
@@ -1805,15 +1805,15 @@ static void mcp_video_stream_task(void* pvParameters) {
             vTaskDelay(pdMS_TO_TICKS(30));
         }
     }
-
+    
     if (mono_client_fd >= 0) close(mono_client_fd);
     if (color_client_fd >= 0) close(color_client_fd);
     if (mono_server_fd >= 0) close(mono_server_fd);
     if (color_server_fd >= 0) close(color_server_fd);
-
+    
     heap_caps_free(mono_buffer);
     heap_caps_free(color_buffer);
-
+    
     LOG_I(TAG, "Video stream server task stopped");
     state.streamTaskHandle = nullptr;
     vTaskDelete(nullptr);
@@ -1829,7 +1829,7 @@ bool startVideoStreamServer() {
     state.tcpBytesReceived = 0;
     state.lastDrawMs = 0;
     state.lastFps = 0.0;
-
+    
     BaseType_t ret = xTaskCreatePinnedToCore(
         mcp_video_stream_task,
         "mcp_video_stream",
@@ -1869,7 +1869,7 @@ bool getVideoStreamStats(std::string& stats_json) {
     cJSON_AddNumberToObject(root, "last_draw_ms", state.lastDrawMs);
     cJSON_AddNumberToObject(root, "last_fps", state.lastFps);
     cJSON_AddBoolToObject(root, "active", state.overrideActive);
-
+    
     char* printed = cJSON_PrintUnformatted(root);
     if (printed != nullptr) {
         stats_json = printed;
@@ -1945,31 +1945,31 @@ bool listSdFiles(const std::string& directory, std::string& files_json, std::str
     if (!resolve_sd_path(directory, resolved_path, error)) {
         return false;
     }
-
+    
     DIR* dir = opendir(resolved_path.c_str());
     if (dir == nullptr) {
         error = "Failed to open directory";
         return false;
     }
-
+    
     cJSON* root = cJSON_CreateObject();
     cJSON* file_array = cJSON_AddArrayToObject(root, "files");
-
+    
     struct dirent* entry;
     while ((entry = readdir(dir)) != nullptr) {
         if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) {
             continue;
         }
-
+        
         cJSON* item = cJSON_CreateObject();
         cJSON_AddStringToObject(item, "name", entry->d_name);
-
+        
         std::string full_filepath = resolved_path;
         if (!full_filepath.ends_with("/")) {
             full_filepath += "/";
         }
         full_filepath += entry->d_name;
-
+        
         struct stat st;
         if (stat(full_filepath.c_str(), &st) == 0) {
             bool is_dir = S_ISDIR(st.st_mode);
@@ -1983,7 +1983,7 @@ bool listSdFiles(const std::string& directory, std::string& files_json, std::str
         cJSON_AddItemToArray(file_array, item);
     }
     closedir(dir);
-
+    
     char* printed = cJSON_PrintUnformatted(root);
     if (printed != nullptr) {
         files_json = printed;

Tactility/Source/service/displayidle/DisplayIdle.cpp

@@ -5,6 +5,9 @@
 #include <Tactility/service/ServiceRegistration.h>
 #include <Tactility/mcp/McpSystem.h>
 
+#include <app/manager.h>
+#include <app/start.h>
+
 #include "BouncingBallsScreensaver.h"
 #include "MatrixRainScreensaver.h"
 #include "MystifyScreensaver.h"
@@ -61,6 +64,34 @@ static bool hasDisplayWithBacklight() {
     return result;
 }
 
+/**
+ * Effective backlight duty for the screensaver: the dimmed night level when
+ * night dim is enabled and the local hour is inside the configured window,
+ * otherwise the regular duty. A start == end window covers the whole day.
+ */
+static uint8_t screensaverBacklightDuty(const settings::display::DisplaySettings& displaySettings) {
+    if (!displaySettings.nightDimEnabled) {
+        return displaySettings.backlightDuty;
+    }
+    const std::time_t now = std::time(nullptr);
+    std::tm local_time {};
+    if (localtime_r(&now, &local_time) == nullptr || local_time.tm_year < 125) {
+        return displaySettings.backlightDuty;
+    }
+    const uint8_t hour = static_cast<uint8_t>(local_time.tm_hour);
+    const uint8_t start = displaySettings.nightDimStartHour;
+    const uint8_t end = displaySettings.nightDimEndHour;
+    bool in_window;
+    if (start == end) {
+        in_window = true;
+    } else if (start < end) {
+        in_window = hour >= start && hour < end;
+    } else {
+        in_window = hour >= start || hour < end;
+    }
+    return in_window ? displaySettings.nightDimDuty : displaySettings.backlightDuty;
+}
+
 void DisplayIdleService::stopScreensaver() {
     if (!lvgl_try_lock(100)) {
         // Lock failed - keep flag set to retry on next tick
@@ -79,6 +110,17 @@ void DisplayIdleService::stopScreensaver() {
         screensaverOverlay = nullptr;
     }
     lvgl_unlock();
+
+    // Stop an app launched as screensaver (e.g. Bible Verse): on wake the
+    // device returns to the launcher. Stopping is safe when the user already
+    // closed it (unknown ids report STOPPED / stop is a no-op for them).
+    if (screensaverAppActive) {
+        screensaverAppActive = false;
+        if (screensaverAppInstanceId != 0) {
+            app_manager_stop(screensaverAppInstanceId);
+            screensaverAppInstanceId = 0;
+        }
+    }
     stopScreensaverRequested.store(false, std::memory_order_relaxed);
 
     // Reset auto-off state
@@ -94,14 +136,31 @@ void DisplayIdleService::stopScreensaver() {
 }
 
 void DisplayIdleService::activateScreensaver() {
-    lv_obj_t* top = lv_layer_top();
-
-    if (screensaverOverlay != nullptr) return;
-
     // Reset auto-off counter when starting screensaver
     screensaverActiveCounter = 0;
     backlightOff = false;
 
+    // Bible Verse screensaver: launch the app instead of drawing an overlay.
+    // Falls back to a plain black overlay when the app is not installed.
+    if (cachedDisplaySettings.screensaverType == settings::display::ScreensaverType::BibleVerse) {
+        constexpr auto* BIBLE_VERSE_APP_ID = "one.tactility.bibleverse";
+        AppManifest manifest {};
+        AppInstanceId instance_id = 0;
+        if (app_manager_find_manifest(BIBLE_VERSE_APP_ID, &manifest) == ERROR_NONE
+            && app_start(BIBLE_VERSE_APP_ID, 0, nullptr, &instance_id) == ERROR_NONE) {
+            LOG_I(TAG, "Bible Verse screensaver: launched instance %u", (unsigned)instance_id);
+            screensaverAppInstanceId = instance_id;
+            screensaverAppActive = true;
+            setBacklightBrightness(screensaverBacklightDuty(cachedDisplaySettings));
+            return;
+        }
+        LOG_W(TAG, "Bible Verse app not installed, falling back to black screen");
+    }
+
+    lv_obj_t* top = lv_layer_top();
+
+    if (screensaverOverlay != nullptr) return;
+
     lv_coord_t screenW = lv_display_get_horizontal_resolution(nullptr);
     lv_coord_t screenH = lv_display_get_vertical_resolution(nullptr);
 
@@ -142,6 +201,8 @@ void DisplayIdleService::activateScreensaver() {
     if (screensaver) {
         screensaver->start(screensaverOverlay, screenW, screenH);
     }
+
+    setBacklightBrightness(screensaverBacklightDuty(cachedDisplaySettings));
 }
 
 void DisplayIdleService::updateScreensaver() {
@@ -171,8 +232,8 @@ void DisplayIdleService::tick() {
     inactive_ms = lv_display_get_inactive_time(nullptr);
 
     // Only update if not stopping (prevents lag on touch)
-    if (displayDimmed && screensaverOverlay && !stopScreensaverRequested.load(std::memory_order_acquire)) {
-        // Check if screensaver should auto-off after 5 minutes
+    if (displayDimmed && (screensaverOverlay || screensaverAppActive) && !stopScreensaverRequested.load(std::memory_order_acquire)) {
+        // Check if screensaver should auto-off after 30 minutes
         if (!backlightOff) {
             screensaverActiveCounter++;
             if (screensaverActiveCounter >= SCREENSAVER_AUTO_OFF_TICKS) {
@@ -181,6 +242,13 @@ void DisplayIdleService::tick() {
                     screensaver->stop();
                     screensaver.reset();
                 }
+                if (screensaverAppActive) {
+                    screensaverAppActive = false;
+                    if (screensaverAppInstanceId != 0) {
+                        app_manager_stop(screensaverAppInstanceId);
+                        screensaverAppInstanceId = 0;
+                    }
+                }
                 setBacklightBrightness(0);
                 backlightOff = true;
             } else {
@@ -216,6 +284,10 @@ void DisplayIdleService::tick() {
                 }
                 displayDimmed = true;
             } else if (displayDimmed && (inactive_ms < kWakeActivityThresholdMs)) {
+                // The Bible Verse app keeps LVGL timers running (minute-advance),
+                // so plain inactivity never drops while it is up. Taps still
+                // register as activity: stop the verse app to return to launcher.
+                // If the user already closed it, stopScreensaver() is a safe no-op.
                 stopScreensaver();
             }
         }
@@ -252,6 +324,13 @@ void DisplayIdleService::onStop(ServiceContext& service) {
             LOG_W(TAG, "Failed to stop screensaver during shutdown - potential resource leak");
         }
     }
+    if (screensaverAppActive) {
+        screensaverAppActive = false;
+        if (screensaverAppInstanceId != 0) {
+            app_manager_stop(screensaverAppInstanceId);
+            screensaverAppInstanceId = 0;
+        }
+    }
     screensaver.reset();
 }
 
@@ -264,8 +343,19 @@ void DisplayIdleService::startScreensaver() {
     // Note: This is safe because we hold the LVGL lock which serializes with tick()
     cachedDisplaySettings = settings::display::loadOrGetDefault();
 
+    // The Bible Verse path launches an app task (not an overlay), which must
+    // not run under the LVGL lock: drop it before activating.
+    const bool launches_app =
+        cachedDisplaySettings.screensaverType == settings::display::ScreensaverType::BibleVerse;
+    if (launches_app) {
+        lvgl_unlock();
+    }
+
     activateScreensaver();
-    lvgl_unlock();
+
+    if (!launches_app) {
+        lvgl_unlock();
+    }
 
     // Turn off backlight for "None" screensaver
     if (hasDisplayWithBacklight() && cachedDisplaySettings.screensaverType == settings::display::ScreensaverType::None) {
@@ -275,7 +365,7 @@ void DisplayIdleService::startScreensaver() {
 }
 
 bool DisplayIdleService::isScreensaverActive() const {
-    return screensaverOverlay != nullptr;
+    return screensaverOverlay != nullptr || screensaverAppActive;
 }
 
 void DisplayIdleService::startMcpScreensaver() {
@@ -301,7 +391,7 @@ void DisplayIdleService::startMcpScreensaver() {
     screensaverActiveCounter = 0;
     backlightOff = false;
     setBacklightBrightness(cachedDisplaySettings.backlightDuty == 0
-        ? 255 : cachedDisplaySettings.backlightDuty);
+        ? 255 : screensaverBacklightDuty(cachedDisplaySettings));
 
     lv_coord_t screenW = lv_display_get_horizontal_resolution(nullptr);
     lv_coord_t screenH = lv_display_get_vertical_resolution(nullptr);

Tactility/Source/service/webserver/McpHandler.cpp

@@ -2,7 +2,6 @@
 
 #include <Tactility/service/webserver/WebServerService.h>
 #include <Tactility/mcp/McpSystem.h>
-#include <Tactility/settings/McpSettings.h>
 
 #include <tactility/log.h>
 
@@ -674,7 +673,7 @@ static cJSON* handle_tool_call(cJSON* id, cJSON* params) {
             ? make_tool_result(id, "Successfully played base64 MP3 audio.")
             : make_error(id, -32020, error.c_str());
     }
-
+    
     if (strcmp(name, "set_led") == 0) {
         cJSON* r_item = cJSON_GetObjectItemCaseSensitive(arguments, "r");
         cJSON* g_item = cJSON_GetObjectItemCaseSensitive(arguments, "g");
@@ -776,7 +775,7 @@ static cJSON* handle_tool_call(cJSON* id, cJSON* params) {
     if (strcmp(name, "get_video_streaming_instructions") == 0) {
         cJSON* protocol_item = cJSON_GetObjectItemCaseSensitive(arguments, "protocol");
         const char* protocol = cJSON_IsString(protocol_item) ? protocol_item->valuestring : "all";
-
+        
         char buf[512];
         snprintf(buf, sizeof(buf),
                  "Tactility OS TCP Video Streaming Instructions:\n"
@@ -884,11 +883,6 @@ static cJSON* handle_rpc(const char* body) {
 error_t WebServerService::handleApiMcp(HttpServerRequest* request, void*) {
     LOG_I(TAG, "POST /api/mcp");
 
-    if (!settings::mcp::loadOrGetDefault().mcpEnabled) {
-        http_server_request_send_error(request, 404, "MCP server is disabled");
-        return ERROR_UNDEFINED;
-    }
-
     const uint64_t declared_length = http_server_request_get_content_length(request);
     if (declared_length == 0 || declared_length > MCP_JSON_BODY_LIMIT) {
         http_server_request_send_error(request, 400, "Invalid Content-Length");
@@ -955,11 +949,6 @@ static int query_integer(const char* query, const char* name, int default_value)
 error_t WebServerService::handleApiScreenRaw(HttpServerRequest* request, void*) {
     LOG_I(TAG, "POST /api/screen/raw");
 
-    if (!settings::mcp::loadOrGetDefault().mcpEnabled) {
-        http_server_request_send_error(request, 404, "MCP server is disabled");
-        return ERROR_UNDEFINED;
-    }
-
     const uint64_t declared_length = http_server_request_get_content_length(request);
     if (declared_length == 0 || declared_length > MCP_RAW_BODY_LIMIT) {
         http_server_request_send_error(request, 400, "Invalid Content-Length");

Tactility/Source/service/webserver/McpSimulatorHandler.cpp

@@ -0,0 +1,258 @@
+#ifndef ESP_PLATFORM
+
+#include <Tactility/service/webserver/WebServerService.h>
+#include <Tactility/lvgl/Lvgl.h>
+#include <lvgl/lvgl.h>
+#include <app/manager.h>
+#include <app/start.h>
+#include <cJSON.h>
+#include <http/server.h>
+
+#include <cstdlib>
+#include <cstring>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace tt::service::webserver {
+namespace {
+constexpr size_t JSON_BODY_LIMIT = 64 * 1024;
+lv_obj_t* gCanvas = nullptr;
+bool gCanvasBlack = false;
+
+lv_obj_t* getCanvas() {
+    if (gCanvas != nullptr) return gCanvas;
+    lv_display_t* display = lv_display_get_default();
+    if (display == nullptr) return nullptr;
+    lv_obj_t* layer = lv_display_get_layer_top(display);
+    gCanvas = lv_obj_create(layer);
+    lv_obj_set_pos(gCanvas, 0, 0);
+    lv_obj_set_size(gCanvas, lv_display_get_horizontal_resolution(display), lv_display_get_vertical_resolution(display));
+    lv_obj_set_style_pad_all(gCanvas, 0, LV_PART_MAIN);
+    lv_obj_set_style_border_width(gCanvas, 0, LV_PART_MAIN);
+    lv_obj_set_style_bg_opa(gCanvas, LV_OPA_TRANSP, LV_PART_MAIN);
+    lv_obj_clear_flag(gCanvas, LV_OBJ_FLAG_SCROLLABLE);
+    lv_obj_clear_flag(gCanvas, LV_OBJ_FLAG_CLICKABLE);
+    return gCanvas;
+}
+
+bool clearCanvas(int color) {
+    lv_obj_t* canvas = getCanvas();
+    if (canvas == nullptr) return false;
+    lv_obj_clean(canvas);
+    gCanvasBlack = color == 1;
+    lv_obj_set_style_bg_color(canvas, gCanvasBlack ? lv_color_black() : lv_color_white(), LV_PART_MAIN);
+    lv_obj_set_style_bg_opa(canvas, LV_OPA_COVER, LV_PART_MAIN);
+    return true;
+}
+
+bool drawCanvasText(const char* text, int x, int y) {
+    lv_obj_t* canvas = getCanvas();
+    if (canvas == nullptr) return false;
+    lv_obj_t* label = lv_label_create(canvas);
+    lv_label_set_text(label, text);
+    lv_obj_set_pos(label, x, y);
+    lv_obj_set_style_text_color(label, gCanvasBlack ? lv_color_white() : lv_color_black(), LV_PART_MAIN);
+    return true;
+}
+
+cJSON* makeError(const cJSON* id, int code, const char* message) {
+    cJSON* response = cJSON_CreateObject();
+    cJSON_AddStringToObject(response, "jsonrpc", "2.0");
+    cJSON* error = cJSON_AddObjectToObject(response, "error");
+    cJSON_AddNumberToObject(error, "code", code);
+    cJSON_AddStringToObject(error, "message", message);
+    if (id != nullptr) cJSON_AddItemToObject(response, "id", cJSON_Duplicate(id, true));
+    else cJSON_AddNullToObject(response, "id");
+    return response;
+}
+
+cJSON* makeTextResult(const cJSON* id, const char* text, bool isError = false) {
+    cJSON* response = cJSON_CreateObject();
+    cJSON_AddStringToObject(response, "jsonrpc", "2.0");
+    cJSON* result = cJSON_AddObjectToObject(response, "result");
+    cJSON* content = cJSON_AddArrayToObject(result, "content");
+    cJSON* item = cJSON_CreateObject();
+    cJSON_AddStringToObject(item, "type", "text");
+    cJSON_AddStringToObject(item, "text", text);
+    cJSON_AddItemToArray(content, item);
+    if (isError) cJSON_AddBoolToObject(result, "isError", true);
+    if (id != nullptr) cJSON_AddItemToObject(response, "id", cJSON_Duplicate(id, true));
+    else cJSON_AddNullToObject(response, "id");
+    return response;
+}
+
+cJSON* makeToolList(const cJSON* id) {
+    cJSON* response = cJSON_CreateObject();
+    cJSON_AddStringToObject(response, "jsonrpc", "2.0");
+    cJSON* result = cJSON_AddObjectToObject(response, "result");
+    cJSON* tools = cJSON_AddArrayToObject(result, "tools");
+
+    cJSON* capabilities = cJSON_CreateObject();
+    cJSON_AddStringToObject(capabilities, "name", "get_capabilities");
+    cJSON_AddStringToObject(capabilities, "description", "Get the simulator platform and display capability information.");
+    cJSON_AddItemToObject(capabilities, "inputSchema", cJSON_Parse("{\"type\":\"object\",\"properties\":{}}"));
+    cJSON_AddItemToArray(tools, capabilities);
+
+    cJSON* listApps = cJSON_CreateObject();
+    cJSON_AddStringToObject(listApps, "name", "list_apps");
+    cJSON_AddStringToObject(listApps, "description", "List apps available in the simulator.");
+    cJSON_AddItemToObject(listApps, "inputSchema", cJSON_Parse("{\"type\":\"object\",\"properties\":{}}"));
+    cJSON_AddItemToArray(tools, listApps);
+
+    cJSON* runApp = cJSON_CreateObject();
+    cJSON_AddStringToObject(runApp, "name", "run_app");
+    cJSON_AddStringToObject(runApp, "description", "Launch an installed simulator app by its app ID.");
+    cJSON_AddItemToObject(runApp, "inputSchema", cJSON_Parse("{\"type\":\"object\",\"properties\":{\"app_id\":{\"type\":\"string\"}},\"required\":[\"app_id\"]}"));
+    cJSON_AddItemToArray(tools, runApp);
+
+    cJSON* clearScreen = cJSON_CreateObject();
+    cJSON_AddStringToObject(clearScreen, "name", "clear_screen");
+    cJSON_AddStringToObject(clearScreen, "description", "Clear the MCP drawing canvas to white (0) or black (1).");
+    cJSON_AddItemToObject(clearScreen, "inputSchema", cJSON_Parse("{\"type\":\"object\",\"properties\":{\"color\":{\"type\":\"integer\",\"enum\":[0,1]}},\"required\":[\"color\"]}"));
+    cJSON_AddItemToArray(tools, clearScreen);
+
+    cJSON* drawText = cJSON_CreateObject();
+    cJSON_AddStringToObject(drawText, "name", "draw_text");
+    cJSON_AddStringToObject(drawText, "description", "Draw text on the simulator MCP canvas at x,y coordinates.");
+    cJSON_AddItemToObject(drawText, "inputSchema", cJSON_Parse("{\"type\":\"object\",\"properties\":{\"text\":{\"type\":\"string\"},\"x\":{\"type\":\"integer\"},\"y\":{\"type\":\"integer\"}},\"required\":[\"text\",\"x\",\"y\"]}"));
+    cJSON_AddItemToArray(tools, drawText);
+
+    if (id != nullptr) cJSON_AddItemToObject(response, "id", cJSON_Duplicate(id, true));
+    else cJSON_AddNullToObject(response, "id");
+    return response;
+}
+
+std::string listAppsJson() {
+    std::vector<const AppManifest*> manifests;
+    app_manager_for_each_manifest([](const AppManifest* manifest, void* context) {
+        static_cast<std::vector<const AppManifest*>*>(context)->push_back(manifest);
+    }, &manifests);
+
+    cJSON* apps = cJSON_CreateArray();
+    for (const AppManifest* manifest : manifests) {
+        cJSON* app = cJSON_CreateObject();
+        cJSON_AddStringToObject(app, "id", manifest->id);
+        cJSON_AddStringToObject(app, "name", manifest->name);
+        cJSON_AddItemToArray(apps, app);
+    }
+    char* text = cJSON_PrintUnformatted(apps);
+    std::string output = text == nullptr ? "[]" : text;
+    cJSON_free(text);
+    cJSON_Delete(apps);
+    return output;
+}
+
+cJSON* handleCall(const cJSON* id, const cJSON* params) {
+    const cJSON* name = cJSON_GetObjectItemCaseSensitive(params, "name");
+    const cJSON* args = cJSON_GetObjectItemCaseSensitive(params, "arguments");
+    if (!cJSON_IsString(name) || (args != nullptr && !cJSON_IsObject(args))) {
+        return makeError(id, -32602, "Invalid params");
+    }
+
+    if (strcmp(name->valuestring, "clear_screen") == 0) {
+        const cJSON* color = cJSON_GetObjectItemCaseSensitive(args, "color");
+        if (!cJSON_IsNumber(color) || (color->valueint != 0 && color->valueint != 1)) {
+            return makeError(id, -32602, "color must be 0 (white) or 1 (black)");
+        }
+        lvgl_lock();
+        const bool cleared = clearCanvas(color->valueint);
+        lvgl_unlock();
+        return cleared ? makeTextResult(id, "ok") : makeTextResult(id, "no active display", true);
+    }
+    if (strcmp(name->valuestring, "draw_text") == 0) {
+        const cJSON* text = cJSON_GetObjectItemCaseSensitive(args, "text");
+        const cJSON* x = cJSON_GetObjectItemCaseSensitive(args, "x");
+        const cJSON* y = cJSON_GetObjectItemCaseSensitive(args, "y");
+        if (!cJSON_IsString(text) || text->valuestring == nullptr || strlen(text->valuestring) > 4096 ||
+            !cJSON_IsNumber(x) || !cJSON_IsNumber(y) || x->valueint < 0 || y->valueint < 0) {
+            return makeError(id, -32602, "text, non-negative x and y are required (text max 4096 chars)");
+        }
+        lvgl_lock();
+        lv_display_t* display = lv_display_get_default();
+        const bool inBounds = display != nullptr && x->valueint < lv_display_get_horizontal_resolution(display) &&
+            y->valueint < lv_display_get_vertical_resolution(display);
+        const bool drawn = inBounds && drawCanvasText(text->valuestring, x->valueint, y->valueint);
+        lvgl_unlock();
+        if (!inBounds) return makeError(id, -32602, "coordinates are outside the simulator display");
+        return drawn ? makeTextResult(id, "ok") : makeTextResult(id, "could not draw on display", true);
+    }
+    if (strcmp(name->valuestring, "get_capabilities") == 0) {
+        return makeTextResult(id, "{\"platform\":\"tactility-simulator\",\"mcp\":true,\"drawing\":true}");
+    }
+    if (strcmp(name->valuestring, "list_apps") == 0) {
+        const std::string apps = listAppsJson();
+        return makeTextResult(id, apps.c_str());
+    }
+    if (strcmp(name->valuestring, "run_app") == 0) {
+        const cJSON* appId = cJSON_GetObjectItemCaseSensitive(args, "app_id");
+        if (!cJSON_IsString(appId) || appId->valuestring == nullptr || appId->valuestring[0] == '\0') {
+            return makeError(id, -32602, "app_id is required");
+        }
+        AppManifest manifest{};
+        if (app_manager_find_manifest(appId->valuestring, &manifest) != ERROR_NONE) {
+            return makeTextResult(id, "app not found", true);
+        }
+        AppInstanceId instanceId = 0;
+        const error_t result = app_start(appId->valuestring, 0, nullptr, &instanceId);
+        if (result != ERROR_NONE) return makeTextResult(id, "app launch failed", true);
+        return makeTextResult(id, "ok");
+    }
+    return makeError(id, -32602, "Unknown simulator MCP tool");
+}
+
+cJSON* handleRpc(const char* body) {
+    cJSON* request = cJSON_Parse(body);
+    if (request == nullptr) return makeError(nullptr, -32700, "Parse error");
+    const cJSON* id = cJSON_GetObjectItemCaseSensitive(request, "id");
+    const cJSON* version = cJSON_GetObjectItemCaseSensitive(request, "jsonrpc");
+    const cJSON* method = cJSON_GetObjectItemCaseSensitive(request, "method");
+    const cJSON* params = cJSON_GetObjectItemCaseSensitive(request, "params");
+
+    cJSON* response = nullptr;
+    if (!cJSON_IsObject(request) || !cJSON_IsString(version) || strcmp(version->valuestring, "2.0") != 0 || !cJSON_IsString(method)) {
+        response = makeError(id, -32600, "Invalid Request");
+    } else if (strcmp(method->valuestring, "tools/list") == 0) {
+        response = makeToolList(id);
+    } else if (strcmp(method->valuestring, "tools/call") == 0) {
+        response = handleCall(id, params);
+    } else {
+        response = makeError(id, -32601, "Method not found");
+    }
+    cJSON_Delete(request);
+    return response;
+}
+}
+
+error_t WebServerService::handleApiMcp(HttpServerRequest* request, void*) {
+    const uint64_t length = http_server_request_get_content_length(request);
+    if (length == 0 || length > JSON_BODY_LIMIT) {
+        http_server_request_send_error(request, 400, "Invalid Content-Length");
+        return ERROR_INVALID_ARGUMENT;
+    }
+    std::string body(static_cast<size_t>(length), '\0');
+    size_t received = 0;
+    while (received < body.size()) {
+        const int count = http_server_request_receive(request, body.data() + received, body.size() - received);
+        if (count <= 0) {
+            http_server_request_send_error(request, 400, "Incomplete request body");
+            return ERROR_UNDEFINED;
+        }
+        received += static_cast<size_t>(count);
+    }
+
+    cJSON* response = handleRpc(body.c_str());
+    char* text = cJSON_PrintUnformatted(response);
+    cJSON_Delete(response);
+    if (text == nullptr) {
+        http_server_request_send_error(request, 500, "Serialization failed");
+        return ERROR_RESOURCE;
+    }
+    http_server_request_set_content_type(request, "application/json");
+    http_server_request_send_string(request, text);
+    cJSON_free(text);
+    return ERROR_NONE;
+}
+}
+
+#endif // ESP_PLATFORM

Tactility/Source/service/webserver/WebServerService.cpp

@@ -26,11 +26,23 @@
 
 #if TT_FEATURE_SCREENSHOT_ENABLED
 #include <lv_screenshot.h>
+// lodepng.h enables its C++ overloads (std::vector/std::string) when compiled
+// as C++; save_png.c compiles it as C. WebServerService.cpp is C++, so opt out
+// of the C++ wrapper to get the same C API save_png.c uses.
+#define LODEPNG_NO_COMPILE_CPP
+#include "src/libs/lodepng/lodepng.h"
 #endif
 
 #include "app/install.h"
 #include "app/manager.h"
 
+#ifndef ESP_PLATFORM
+// Simulator touch injection backend (Devices/simulator sdl-pointer driver).
+// Declared extern "C" here instead of including the device header: Tactility
+// must not depend upward on a device implementation.
+extern "C" void sdl_input_set_touch_override(int32_t x, int32_t y, bool pressed);
+#endif
+
 #ifdef ESP_PLATFORM
 #include <Tactility/mcp/McpSystem.h>
 #include <Tactility/settings/McpSettings.h>
@@ -215,7 +227,11 @@ bool WebServerService::onStart(ServiceContext& service) {
         lock.lock();
         g_cachedSettings = settings::webserver::loadOrGetDefault();
         g_settingsCached = true;
+#ifdef ESP_PLATFORM
         serverEnabled = g_cachedSettings.webServerEnabled || settings::mcp::loadOrGetDefault().mcpEnabled;
+#else
+        serverEnabled = g_cachedSettings.webServerEnabled;
+#endif
     }
     // Subscribe to settings change events to refresh cache
     settingsEventSubscription = pubsub->subscribe([](WebServerEvent event) {
@@ -224,7 +240,11 @@ bool WebServerService::onStart(ServiceContext& service) {
             lock.lock();
             g_cachedSettings = settings::webserver::loadOrGetDefault();
             g_settingsCached = true;
+#ifdef ESP_PLATFORM
             const bool enabled = g_cachedSettings.webServerEnabled || settings::mcp::loadOrGetDefault().mcpEnabled;
+#else
+            const bool enabled = g_cachedSettings.webServerEnabled;
+#endif
             if (g_webServerInstance.load() != nullptr) {
                 g_webServerInstance.load()->setEnabled(enabled);
             }
@@ -487,14 +507,14 @@ bool WebServerService::startServer() {
             .callback  = handleAdminPost,
             .user_ctx  = ctx
         },
-#ifdef ESP_PLATFORM
-        // MCP is LAN-local and is enabled whenever the web server is enabled.
+        // MCP is available on physical devices and the POSIX simulator.
         {
             .uri       = "/api/mcp",
             .method    = HTTP_METHOD_POST,
             .callback  = handleApiMcp,
             .user_ctx  = ctx
         },
+#ifdef ESP_PLATFORM
         {
             .uri       = "/api/screen/raw",
             .method    = HTTP_METHOD_POST,
@@ -521,6 +541,23 @@ bool WebServerService::startServer() {
             .callback  = handleApiPut,
             .user_ctx  = ctx
         },
+#ifndef ESP_PLATFORM
+        // Simulator viewer aliases: the /sim page resolves api/ against its
+        // own directory (/sim/api/...), so mirror the viewer-needed handlers
+        // here. Same callbacks, auth enforced inside each handler.
+        {
+            .uri       = "/sim/api/*",
+            .method    = HTTP_METHOD_GET,
+            .callback  = handleApiGet,
+            .user_ctx  = ctx
+        },
+        {
+            .uri       = "/sim/api/*",
+            .method    = HTTP_METHOD_POST,
+            .callback  = handleApiPost,
+            .user_ctx  = ctx
+        },
+#endif
         {
             .uri       = "/*",  // Catch-all for dynamic assets
             .method    = HTTP_METHOD_GET,
@@ -1038,9 +1075,17 @@ error_t WebServerService::handleAdminPost(HttpServerRequest* request, void* user
 
 // API GET dispatcher - returns JSON system information
 // Note: /api/sysinfo is intentionally public for monitoring use cases
+// The /sim/api/* alias routes (sim viewer page) strip the /sim prefix here
+// so both /api/... and /sim/api/... share one dispatch table.
+static const char* api_path_suffix(HttpServerRequest* request, char* uri, size_t uri_size) {
+    http_server_request_get_uri(request, uri, uri_size);
+    if (strncmp(uri, "/sim/api/", 9) == 0) return uri + 4; // -> /api/...
+    return uri;
+}
+
 error_t WebServerService::handleApiGet(HttpServerRequest* request, void* user_ctx) {
-    char uri[256];
-    http_server_request_get_uri(request, uri, sizeof(uri));
+    char uri_buf[256];
+    const char* uri = api_path_suffix(request, uri_buf, sizeof(uri_buf));
 
     // Public endpoint: sysinfo (basic device info for monitoring)
     if (strncmp(uri, "/api/sysinfo", 12) == 0) {
@@ -1058,6 +1103,9 @@ error_t WebServerService::handleApiGet(HttpServerRequest* request, void* user_ct
     if (strncmp(uri, "/api/apps", 9) == 0) {
         return handleApiApps(request, user_ctx);
     }
+    if (strncmp(uri, "/api/sim/touch", 14) == 0) {
+        return handleApiSimTouch(request, user_ctx);
+    }
     if (strncmp(uri, "/api/wifi", 9) == 0) {
         return handleApiWifi(request, user_ctx);
     }
@@ -1078,11 +1126,14 @@ error_t WebServerService::handleApiPost(HttpServerRequest* request, void* user_c
         return authResult;
     }
 
-    char uri[256];
-    http_server_request_get_uri(request, uri, sizeof(uri));
+    char uri_buf[256];
+    const char* uri = api_path_suffix(request, uri_buf, sizeof(uri_buf));
     if (strncmp(uri, "/api/apps/run", 13) == 0) {
         return handleApiAppsRun(request, user_ctx);
     }
+    if (strncmp(uri, "/api/sim/touch", 14) == 0) {
+        return handleApiSimTouch(request, user_ctx);
+    }
     if (strncmp(uri, "/api/apps/uninstall", 19) == 0) {
         return handleApiAppsUninstall(request, user_ctx);
     }
@@ -1518,11 +1569,76 @@ error_t WebServerService::handleApiWifi(HttpServerRequest* request, void*) {
 }
 
 // GET /api/screenshot - Capture and return screenshot as PNG
-// Screenshots are saved to SD card root (if available) or /data with incrementing numbers
+// Fast path (no query or ?fast=1): snapshot LVGL to a memory buffer, PNG-encode
+// to memory with lodepng, stream directly. No filesystem touch, no slot scan.
+// Legacy path (?fast=0): previous save-to-webscreenshotN.png behavior.
 error_t WebServerService::handleApiScreenshot(HttpServerRequest* request, void*) {
     LOG_I(TAG, "GET /api/screenshot");
 
 #if TT_FEATURE_SCREENSHOT_ENABLED
+    std::string sfast;
+    bool fast = true;
+    if (getQueryParam(request, "fast", sfast)) fast = (sfast != "0");
+
+    if (fast) {
+        // Hold the LVGL lock across snapshot + encode: both must see a stable
+        // framebuffer. lv_snapshot_take renders synchronously under the lock.
+        if (!lvgl_try_lock(pdMS_TO_TICKS(500))) {
+            LOG_E(TAG, "Could not acquire LVGL lock within 500ms");
+            http_server_request_send_error(request, 500, "could not acquire LVGL lock");
+            return ERROR_UNDEFINED;
+        }
+        lv_draw_buf_t* snapshot = lv_snapshot_take(lv_scr_act(), LV_COLOR_FORMAT_RGB888);
+        if (snapshot == nullptr) {
+            lvgl_unlock();
+            LOG_E(TAG, "lv_snapshot_take failed");
+            http_server_request_send_error(request, 500, "snapshot failed");
+            return ERROR_UNDEFINED;
+        }
+        // lodepng wants RGB triplets; snapshot is RGB888 = 3 bytes/px already,
+        // but in BGR order on little-endian — swap R and B in place.
+        uint32_t px_count = snapshot->header.w * snapshot->header.h;
+        uint8_t* px = snapshot->data;
+        for (uint32_t i = 0; i < px_count; i++) {
+            uint8_t tmp = px[0];
+            px[0] = px[2];
+            px[2] = tmp;
+            px += 3;
+        }
+        unsigned char* png = nullptr;
+        size_t png_size = 0;
+        unsigned enc_err = lodepng_encode24(&png, &png_size, snapshot->data,
+            snapshot->header.w, snapshot->header.h);
+        uint32_t w = snapshot->header.w, h = snapshot->header.h;
+        lv_draw_buf_destroy(snapshot);
+        lvgl_unlock();
+        if (enc_err != 0 || png == nullptr) {
+            LOG_E(TAG, "lodepng_encode24 failed: %u", enc_err);
+            http_server_request_send_error(request, 500, "png encode failed");
+            return ERROR_UNDEFINED;
+        }
+        LOG_I(TAG, "Screenshot %lux%lu %d bytes (memory path)", (unsigned long)w, (unsigned long)h, (int)png_size);
+        http_server_request_set_content_type(request, "image/png");
+        error_t result = ERROR_NONE;
+        if (http_server_request_send_chunk_start(request) != ERROR_NONE) {
+            result = ERROR_UNDEFINED;
+        } else {
+            size_t sent = 0;
+            while (sent < png_size) {
+                size_t n = png_size - sent > 8192 ? 8192 : png_size - sent;
+                if (http_server_request_send_chunk(request, png + sent, n) != ERROR_NONE) {
+                    result = ERROR_UNDEFINED;
+                    break;
+                }
+                sent += n;
+            }
+            http_server_request_send_chunk_end(request);
+        }
+        free(png);
+        LOG_I(TAG, "[200] /api/screenshot fast %d bytes", (int)png_size);
+        return result;
+    }
+
     // Determine save location: prefer SD card root if mounted, otherwise /data
     std::string save_path = getDataPath();
 
@@ -1764,6 +1880,83 @@ error_t WebServerService::handleReboot(HttpServerRequest* request, void*) {
     return ERROR_NONE; // Unreachable on ESP_PLATFORM, but satisfies function signature
 }
 
+// POST /api/sim/touch?x=123&y=456[&down=0|1] - inject touch into simulator.
+// Simulator-only: on ESP32 there is no sdl-pointer backend, so this 404s.
+// x/y are LVGL logical pixels (see viewer footer for current WxH).
+// down=1 (default) presses and auto-releases after ~1.5s (long enough for LVGL
+// indev polls to register a click); down=0 releases immediately.
+error_t WebServerService::handleApiSimTouch(HttpServerRequest* request, void*) {
+#ifdef ESP_PLATFORM
+    http_server_request_send_error(request, 404, "simulator only");
+    return ERROR_UNDEFINED;
+#else
+    std::string sx, sy, sdown;
+    int x = -1, y = -1;
+    if (getQueryParam(request, "x", sx)) x = atoi(sx.c_str());
+    if (getQueryParam(request, "y", sy)) y = atoi(sy.c_str());
+    bool down = true;
+    if (getQueryParam(request, "down", sdown)) down = (sdown != "0");
+    if (x < 0 || y < 0 || x > 4096 || y > 4096) {
+        http_server_request_send_error(request, 400, "x and y params required (0..4096)");
+        return ERROR_UNDEFINED;
+    }
+    sdl_input_set_touch_override((int32_t)x, (int32_t)y, down);
+    LOG_I(TAG, "[200] /api/sim/touch x=%d y=%d down=%d", x, y, (int)down);
+    http_server_request_send_string(request, "ok");
+    return ERROR_NONE;
+#endif
+}
+
+// GET /sim - live simulator viewer: MJPEG-style screenshot refresh + click-to-touch.
+error_t WebServerService::handleSimViewer(HttpServerRequest* request, void*) {
+    bool authPassed = false;
+    error_t authResult = validateRequestAuth(request, authPassed);
+    if (!authPassed) {
+        return authResult;
+    }
+    http_server_request_set_content_type(request, "text/html");
+    // NOTE: the page resolves api/ against its own directory (new URL(u,base)).
+    // Locally that is /sim -> /sim/api/...; behind tailscale
+    // (--set-path=/simagent -> /) it is /simagent/sim -> /simagent/api/...
+    // Both need handler aliases, registered in startServer() below:
+    // /sim/api/* mirrors /api/* (screenshot, sim/touch). The page itself must
+    // therefore be served with a trailing-slash-insensitive /sim match so the
+    // browser treats /sim as a directory (see handleAssets /sim route).
+    static const char* page =
+        "<!doctype html><html><head><meta charset=utf-8><meta name=viewport "
+        "content='width=device-width,initial-scale=1'>"
+        "<title>Tactility Sim</title><style>"
+        "body{margin:0;background:#111;color:#eee;font-family:sans-serif;"
+        "display:flex;flex-direction:column;align-items:center;gap:8px;padding:12px}"
+        "img{width:min(96vw,720px);image-rendering:pixelated;border:1px solid #333;"
+        "border-radius:8px;touch-action:none;cursor:crosshair;background:#000}"
+        ".bar{display:flex;gap:8px;align-items:center;font-size:13px;color:#aaa}"
+        "button{background:#313244;color:#fff;border:0;border-radius:8px;padding:6px 12px}"
+        "</style></head><body>"
+        "<div class=bar><b>Tactility Sim</b><span id=st>live</span>"
+        "<button onclick='snap()'>refresh</button></div>"
+        "<img id=scr alt='sim screen'>"
+        "<div class=bar>click/tap the screen to touch &middot; <span id=res></span> logical</div>"
+        "<script>"
+        "const img=document.getElementById('scr'),st=document.getElementById('st'),"
+        "res=document.getElementById('res');"
+        "const base=new URL('.',location.href).href;"
+        "const api=u=>new URL(u,base).href;"
+        "function snap(){img.src=api('api/screenshot?fast=1')+'&ts='+Date.now();}"
+        "setInterval(snap,500);snap();"
+        "img.addEventListener('error',()=>{st.textContent='reconnecting…';});"
+        "img.addEventListener('load',()=>{st.textContent='live';"
+        "res.textContent=img.naturalWidth+'x'+img.naturalHeight;});"
+        "img.addEventListener('pointerdown',e=>{"
+        "const r=img.getBoundingClientRect();"
+        "const x=Math.round((e.clientX-r.left)/r.width*img.naturalWidth);"
+        "const y=Math.round((e.clientY-r.top)/r.height*img.naturalHeight);"
+        "fetch(api('api/sim/touch')+'?x='+x+'&y='+y,{method:'POST'});});"
+        "</script></body></html>";
+    http_server_request_send_string(request, page);
+    return ERROR_NONE;
+}
+
 error_t WebServerService::handleAssets(HttpServerRequest* request, void*) {
     // Auth check for UI access control
     bool authPassed = false;
@@ -1776,6 +1969,32 @@ error_t WebServerService::handleAssets(HttpServerRequest* request, void*) {
     http_server_request_get_uri(request, uri, sizeof(uri));
     LOG_I(TAG, "GET %s", uri);
 
+    // Simulator live viewer (no auth bypass: checked inside handler).
+    // Served with redirect-to-slash so relative api/ URLs resolve under /sim/
+    // (browsers treat /sim as a file, /sim/ as a directory for URL purposes).
+    // NOTE: /sim/api/* does NOT need special-casing here: the /sim/api/*
+    // handler aliases registered in startServer() route straight into
+    // handleApiGet/handleApiPost, which strip the /sim prefix via
+    // api_path_suffix(). This block only serves the viewer page itself.
+    if (strncmp(uri, "/sim", 4) == 0 && (uri[4] == '\0' || uri[4] == '?' || uri[4] == '/')) {
+        // Redirect bare /sim -> /sim/ so relative api/ resolves correctly.
+        if (uri[4] == '\0' || uri[4] == '?') {
+            std::string loc = "/sim/";
+            const char* q = strchr(uri, '?');
+            if (q != nullptr) { loc += q; }
+            http_server_request_set_header(request, "Location", loc.c_str());
+            http_server_request_send_error(request, 301, "see /sim/");
+            return ERROR_NONE;
+        }
+        if (strncmp(uri, "/sim/api/", 9) == 0) {
+            // Should have matched the /sim/api/* alias in startServer(); if we
+            // get here the method has no alias (e.g. PUT) — 404 it.
+            http_server_request_send_error(request, 404, "not found");
+            return ERROR_UNDEFINED;
+        }
+        return handleSimViewer(request, nullptr);
+    }
+
     // Special case: serve favicon from system assets
     if (strcmp(uri, "/favicon.ico") == 0) {
         std::string faviconPathStr = std::string(file::MOUNT_POINT_SYSTEM) + "/spinner.png";

Tactility/Source/settings/AudioSettings.cpp

@@ -117,7 +117,7 @@ bool save(const AudioSettings& settings) {
     map[SETTINGS_KEY_OUTPUT_VOLUME] = toString(settings.outputVolume);
 
     std::string settings_path;
-    if (getSettingsFilePath(settings_path)) {
+    if (!getSettingsFilePath(settings_path)) {
         return false;
     }
 

Tactility/Source/settings/DisplaySettings.cpp

@@ -26,6 +26,10 @@ constexpr auto* SETTINGS_KEY_BACKLIGHT_DUTY = "backlightDuty";
 constexpr auto* SETTINGS_KEY_TIMEOUT_ENABLED = "backlightTimeoutEnabled";
 constexpr auto* SETTINGS_KEY_TIMEOUT_MS = "backlightTimeoutMs";
 constexpr auto* SETTINGS_KEY_SCREENSAVER_TYPE = "screensaverType";
+constexpr auto* SETTINGS_KEY_NIGHT_DIM_ENABLED = "nightDimEnabled";
+constexpr auto* SETTINGS_KEY_NIGHT_DIM_START_HOUR = "nightDimStartHour";
+constexpr auto* SETTINGS_KEY_NIGHT_DIM_END_HOUR = "nightDimEndHour";
+constexpr auto* SETTINGS_KEY_NIGHT_DIM_DUTY = "nightDimDuty";
 
 static Orientation getDefaultOrientation() {
     auto* display = lv_display_get_default();
@@ -117,6 +121,8 @@ static std::string toString(ScreensaverType type) {
             return "StackChan";
         case McpScreen:
             return "McpScreen";
+        case BibleVerse:
+            return "BibleVerse";
         default:
             std::unreachable();
     }
@@ -141,6 +147,9 @@ static bool fromString(const std::string& str, ScreensaverType& type) {
     } else if (str == "McpScreen") {
         type = ScreensaverType::McpScreen;
         return true;
+    } else if (str == "BibleVerse") {
+        type = ScreensaverType::BibleVerse;
+        return true;
     } else {
         return false;
     }
@@ -202,6 +211,30 @@ bool load(DisplaySettings& settings) {
         fromString(screensaver_entry->second, screensaver_type);
     }
 
+    auto night_dim_enabled_entry = map.find(SETTINGS_KEY_NIGHT_DIM_ENABLED);
+    bool night_dim_enabled = false;
+    if (night_dim_enabled_entry != map.end()) {
+        night_dim_enabled = (night_dim_enabled_entry->second == "1" || night_dim_enabled_entry->second == "true" || night_dim_enabled_entry->second == "True");
+    }
+
+    auto night_dim_start_entry = map.find(SETTINGS_KEY_NIGHT_DIM_START_HOUR);
+    int night_dim_start_hour = 22;
+    if (night_dim_start_entry != map.end()) {
+        night_dim_start_hour = atoi(night_dim_start_entry->second.c_str());
+    }
+
+    auto night_dim_end_entry = map.find(SETTINGS_KEY_NIGHT_DIM_END_HOUR);
+    int night_dim_end_hour = 7;
+    if (night_dim_end_entry != map.end()) {
+        night_dim_end_hour = atoi(night_dim_end_entry->second.c_str());
+    }
+
+    auto night_dim_duty_entry = map.find(SETTINGS_KEY_NIGHT_DIM_DUTY);
+    int night_dim_duty = 20;
+    if (night_dim_duty_entry != map.end()) {
+        night_dim_duty = atoi(night_dim_duty_entry->second.c_str());
+    }
+
     settings.orientation = orientation;
     settings.fontSize = font_size;
     settings.gammaCurve = gamma_curve;
@@ -209,6 +242,10 @@ bool load(DisplaySettings& settings) {
     settings.backlightTimeoutEnabled = timeout_enabled;
     settings.backlightTimeoutMs = timeout_ms;
     settings.screensaverType = screensaver_type;
+    settings.nightDimEnabled = night_dim_enabled;
+    settings.nightDimStartHour = static_cast<uint8_t>(night_dim_start_hour < 0 ? 0 : (night_dim_start_hour > 23 ? 23 : night_dim_start_hour));
+    settings.nightDimEndHour = static_cast<uint8_t>(night_dim_end_hour < 0 ? 0 : (night_dim_end_hour > 23 ? 23 : night_dim_end_hour));
+    settings.nightDimDuty = static_cast<uint8_t>(night_dim_duty < 0 ? 0 : (night_dim_duty > 255 ? 255 : night_dim_duty));
 
     return true;
 }
@@ -221,7 +258,11 @@ DisplaySettings getDefault() {
         .backlightDuty = 200,
         .backlightTimeoutEnabled = false,
         .backlightTimeoutMs = 60000,
-        .screensaverType = ScreensaverType::BouncingBalls
+        .screensaverType = ScreensaverType::BouncingBalls,
+        .nightDimEnabled = false,
+        .nightDimStartHour = 22,
+        .nightDimEndHour = 7,
+        .nightDimDuty = 20
     };
 }
 
@@ -242,6 +283,10 @@ bool save(const DisplaySettings& settings) {
     map[SETTINGS_KEY_TIMEOUT_ENABLED] = settings.backlightTimeoutEnabled ? "1" : "0";
     map[SETTINGS_KEY_TIMEOUT_MS] = std::to_string(settings.backlightTimeoutMs);
     map[SETTINGS_KEY_SCREENSAVER_TYPE] = toString(settings.screensaverType);
+    map[SETTINGS_KEY_NIGHT_DIM_ENABLED] = settings.nightDimEnabled ? "1" : "0";
+    map[SETTINGS_KEY_NIGHT_DIM_START_HOUR] = std::to_string(settings.nightDimStartHour);
+    map[SETTINGS_KEY_NIGHT_DIM_END_HOUR] = std::to_string(settings.nightDimEndHour);
+    map[SETTINGS_KEY_NIGHT_DIM_DUTY] = std::to_string(settings.nightDimDuty);
     auto settings_path = getSettingsFilePath();
     if (!file::findOrCreateParentDirectory(settings_path, 0755)) {
         return false;

Tactility/Source/settings/McpSettings.cpp

@@ -34,14 +34,14 @@ bool load(McpSettings& settings) {
     auto mcp_enabled = map.find(KEY_MCP_ENABLED);
     settings.mcpEnabled = (mcp_enabled != map.end())
         ? (mcp_enabled->second == "1" || mcp_enabled->second == "true")
-        : false;
+        : true;
 
     return true;
 }
 
 McpSettings getDefault() {
     return McpSettings{
-        .mcpEnabled = false
+        .mcpEnabled = true
     };
 }
 

Tactility/Source/settings/SystemSettings.cpp

@@ -44,7 +44,7 @@ static bool loadSystemSettingsFromFile(SystemSettings& properties) {
     }
 
     auto time_format_entry = map.find("timeFormat24h");
-    bool time_format_24h = time_format_entry == map.end() ? true : (time_format_entry->second == "true");
+    bool time_format_24h = time_format_entry == map.end() ? false : (time_format_entry->second == "true");
     properties.timeFormat24h = time_format_24h;
 
     // Load date format

Tactility/Source/settings/WebServerSettings.cpp

@@ -164,7 +164,7 @@ bool load(WebServerSettings& settings) {
     // Web server settings
     settings.webServerEnabled = (webserver_enabled != map.end())
         ? (webserver_enabled->second == "1" || webserver_enabled->second == "true")
-        : false;
+        : true;
 
     settings.webServerPort = (webserver_port != map.end())
         ? static_cast<uint16_t>(parseInt(webserver_port->second, 1, 65535, 80))
@@ -206,7 +206,7 @@ WebServerSettings getDefault() {
         .apPassword = "",  // Empty - will be auto-generated on first use (unless apOpenNetwork)
         .apOpenNetwork = false,  // Default to secured network
         .apChannel = 1,
-        .webServerEnabled = false,  // Default WebServer OFF for security
+        .webServerEnabled = true,  // Default WebServer ON (simplified family UI: no toggle exposed)
         .webServerPort = 80,
         .webServerAuthEnabled = false,  // Auth disabled by default
         .webServerUsername = "",  // Empty - will be generated if auth is enabled

Tactility/Source/settings/time.cpp

@@ -75,7 +75,7 @@ std::string getTimeZoneName() {
             }
         }
     }
-    return "Europe/Amsterdam";
+    return "America/New_York";
 }
 
 bool hasTimeZone() {
@@ -105,13 +105,13 @@ std::string getTimeZoneCode() {
             }
         }
     }
-    return "CET-1CEST,M3.5.0,M10.5.0/3";  // Default: Europe/Amsterdam
+    return "EST5EDT,M3.2.0,M11.1.0";  // Default: America/New_York
 }
 
 bool isTimeFormat24Hour() {
     SystemSettings properties;
     if (!loadSystemSettings(properties)) {
-        return true;
+        return false;
     } else {
         return properties.timeFormat24h;
     }

Tactility/Tests/CMakeLists.txt

@@ -19,18 +19,9 @@ target_include_directories(TactilityTests PRIVATE ${CMAKE_CURRENT_LIST_DIR}/../P
 
 add_test(NAME TactilityTests COMMAND TactilityTests)
 
-# Matches Tactility/CMakeLists.txt's own set of --wrap flags: this binary also compiles
-# AppStdioWrap.cpp and links app-module (whose io.cpp calls __real_read/write/close() on
-# non-Apple POSIX - see TT_APP_IO_WRAPS_STDIO in Modules/app-module/CMakeLists.txt), so it
-# needs the same wraps applied or those go unresolved.
-if (NOT APPLE)
-    target_link_options(TactilityTests PRIVATE
-        "-Wl,--wrap=pthread_attr_setstack" "-Wl,--wrap=read" "-Wl,--wrap=write" "-Wl,--wrap=close"
-        "-Wl,--wrap=printf" "-Wl,--wrap=fprintf" "-Wl,--wrap=vprintf" "-Wl,--wrap=vfprintf"
-        "-Wl,--wrap=puts" "-Wl,--wrap=fputs" "-Wl,--wrap=putchar" "-Wl,--wrap=fputc"
-        "-Wl,--wrap=getchar" "-Wl,--wrap=fgetc" "-Wl,--wrap=fgets"
-    )
-endif ()
+# No --wrap flags declared here: linking platform-posix and app-module below already brings all
+# of pthread_attr_setstack/read/write/close/the printf family along (see their own CMakeLists.txt
+# files).
 
 target_link_libraries(TactilityTests PRIVATE
     TactilityKernel

Tests/CMakeLists.txt

@@ -11,6 +11,7 @@ add_subdirectory(${CMAKE_SOURCE_DIR}/Modules/crypt-module/tests ${CMAKE_CURRENT_
 add_subdirectory(${CMAKE_SOURCE_DIR}/Modules/app-module/tests ${CMAKE_CURRENT_BINARY_DIR}/app-module)
 add_subdirectory(${CMAKE_SOURCE_DIR}/Modules/app-posix-module/tests ${CMAKE_CURRENT_BINARY_DIR}/app-posix-module)
 add_subdirectory(${CMAKE_SOURCE_DIR}/Modules/http-module/tests ${CMAKE_CURRENT_BINARY_DIR}/http-module)
+add_subdirectory(${CMAKE_SOURCE_DIR}/Devices/simulator/tests ${CMAKE_CURRENT_BINARY_DIR}/simulator)
 
 add_custom_target(build-tests)
 add_dependencies(build-tests ServiceModuleTests)
@@ -21,3 +22,4 @@ add_dependencies(build-tests CryptModuleTests)
 add_dependencies(build-tests AppModuleTests)
 add_dependencies(build-tests AppPosixModuleTests)
 add_dependencies(build-tests HttpModuleTests)
+add_dependencies(build-tests SimulatorAudioTests)

flash-es3c.sh

@@ -0,0 +1,77 @@
+#!/bin/zsh
+# Build and flash LCDWIKI ES3C28P / ES3C35P firmware.
+#
+# Usage:
+#   ./flash-es3c.sh 35p [port] [--build-only]
+#   ./flash-es3c.sh 28p [port] [--build-only]
+#
+# If port is omitted, the single /dev/cu.usbmodem* device is used.
+# Each board keeps its own build dir (build-es3c28p / build-es3c35p),
+# so switching boards only rewrites sdkconfig via device.py.
+set -eu -o pipefail
+
+FIRMWARE_DIR="$(cd "$(dirname "$0")" && pwd)"
+cd "$FIRMWARE_DIR"
+SCRIPT_NAME="$(basename "$0")"
+
+usage() {
+    echo "Usage: ${SCRIPT_NAME} <28p|35p> [port] [--build-only]"
+    echo "  port defaults to the single /dev/cu.usbmodem* device"
+}
+
+if (( $# == 0 )); then
+    usage
+    exit 1
+fi
+
+case "$1" in
+    28p|es3c28p) DEVICE_ID="es3c28p" ;;
+    35p|es3c35p) DEVICE_ID="es3c35p" ;;
+    -h|--help|help) usage; exit 0 ;;
+    *) echo "Unknown device '$1' (expected 28p or 35p)"; usage; exit 1 ;;
+esac
+shift
+
+PORT=""
+BUILD_ONLY=0
+for arg in "$@"; do
+    case "$arg" in
+        --build-only) BUILD_ONLY=1 ;;
+        *) PORT="$arg" ;;
+    esac
+done
+
+if (( ! BUILD_ONLY )) && [[ -z "$PORT" ]]; then
+    candidates=(/dev/cu.usbmodem*(N))
+    if (( ${#candidates} == 0 )); then
+        echo "No /dev/cu.usbmodem* device found. Connect the board or pass the port explicitly."
+        exit 1
+    fi
+    if (( ${#candidates} > 1 )); then
+        echo "Multiple USB modem devices found:"
+        printf '  %s\n' "${candidates[@]}"
+        echo "Unplug one board or pass the port explicitly."
+        exit 1
+    fi
+    PORT="${candidates[1]}"
+fi
+
+# IDF 5.5 environment (host venvs corrupt IDF tooling, so pin the IDF python env)
+unset VIRTUAL_ENV PYTHONPATH PYTHONHOME
+export IDF_PYTHON_ENV_PATH=/Users/adolforeyna/.espressif/python_env/idf5.5_py3.9_env
+source /Users/adolforeyna/esp/esp-idf/export.sh
+
+BUILD_DIR="build-${DEVICE_ID}"
+"$IDF_PYTHON_ENV_PATH/bin/python" device.py "$DEVICE_ID"
+idf.py -B "$BUILD_DIR" reconfigure build
+
+if (( BUILD_ONLY )); then
+    echo "Build done (${BUILD_DIR}/Tactility.bin). Skipping flash (--build-only)."
+    exit 0
+fi
+
+echo "=== Confirming board on ${PORT} ==="
+"$IDF_PYTHON_ENV_PATH/bin/python" -m esptool --chip esp32s3 -p "$PORT" chip_id | grep -E "Chip is|MAC:"
+
+idf.py -B "$BUILD_DIR" -p "$PORT" -b 460800 flash
+echo "Flashed ${DEVICE_ID} on ${PORT}."