Promote Tiberian Sun string port

Port the localized mission-completion logic with explicit UTF-8 decoding, ASCII normalization, and fallible byte-boundary slices. Add a deterministic host fixture for process and module identity, 64-bit traversal, full-bound and NUL-terminated text, timer actions, and detach.

Author: CryZe

README.md

@@ -205,7 +205,9 @@ native UTF-16 case in
 timer-metadata and monotonic-delay case is recorded in
 [`docs/DARK_SASI_PORT.md`](docs/DARK_SASI_PORT.md), and the ASL process-name
 migration and multi-layout case in
-[`docs/NIOH_RTA_NO_LOAD_PORT.md`](docs/NIOH_RTA_NO_LOAD_PORT.md).
+[`docs/NIOH_RTA_NO_LOAD_PORT.md`](docs/NIOH_RTA_NO_LOAD_PORT.md). The focused
+ASCII string-normalization case is recorded in
+[`docs/TIBERIAN_SUN_PORT.md`](docs/TIBERIAN_SUN_PORT.md).
 
 ## What works now
 

docs/ROADMAP_ARCHIVE.md

@@ -1,5 +1,20 @@
 # SplitScript roadmap
 
+## 2026-08-09: explicit ASCII string normalization
+
+- Added immutable `String.toAsciiLowerCase()` with an intentionally narrow
+  ASCII contract. It changes only `A` through `Z`, preserves all other UTF-8
+  bytes, and reuses the receiver without allocation when no byte changes.
+- Kept the API in the source-defined standard-library catalog with its docs,
+  example, must-use obligation, signature, effects, completion, and hover.
+  Rust owns only the validated Wasm GC byte-transform helper.
+- Extended the string runtime fixture across mixed ASCII, non-ASCII UTF-8, and
+  already-normalized input, and documented C# `ToLower()` migration without
+  pretending to provide culture-sensitive Unicode casing.
+- Promoted Tiberian Sun as the motivating maintained port, covering its
+  localized completion-text patterns, explicit native decoding, fallible byte
+  slices, timer behavior, and process lifecycle in a deterministic host.
+
 ## 2026-08-09: faithful Nioh multi-layout port
 
 - Replaced the campaign's unsafe newest-version fallback with a maintained

docs/TIBERIAN_SUN_PORT.md

@@ -0,0 +1,35 @@
+# Tiberian Sun autosplitter port
+
+This maintained port is based on `TiberianSun.asl` from the reviewed corpus.
+It exercises the new ASCII normalization operation against the source's actual
+localized mission-completion logic rather than treating a compile probe as
+behavioral evidence.
+
+## Preserved behavior
+
+| ASL behavior | SplitScript representation |
+| --- | --- |
+| Attach to ASL's extensionless `game` process | `state "game.exe"` for the current Windows host contract |
+| Remove loads when `isPlaying` is zero | Original `isLoading` predicate |
+| Start on the vanilla or Firestorm menu-to-game transition | Original menu and game-state edge |
+| Lowercase localized splash text | `toAsciiLowerCase()` with explicit ASCII semantics |
+| Match English, German, and French completion text | Byte-boundary slices at offsets 7 and 11 |
+| Match Spanish `MISION CUMPLIDA` | Lowercase `c` at byte offset 7 |
+
+The source uses ASL `string20`, whose runtime guesses UTF-16LE from the second
+byte. The known splash identifiers used by this script are ASCII, so the port
+chooses `utf8(20)` explicitly. This makes the memory contract auditable and
+keeps byte offsets equivalent to the source's .NET character indexes for the
+supported patterns. A future non-ASCII localization would require revisiting
+that evidence rather than silently relying on these offsets.
+
+`slice` is fallible because arbitrary UTF-8 byte offsets can land inside a code
+point. Both accesses therefore return `false` on malformed or unexpectedly
+short text instead of trapping or manufacturing a character value.
+
+## Runtime status
+
+The deterministic host fixture covers the exact `.exe` process/module names,
+64-bit pointer traversal, a full-bound 20-byte English string without a NUL,
+a shorter NUL-terminated Spanish string, a rejected non-completion message,
+vanilla start, loading pause/resume order, two splits, and detach.

examples/tiberian_sun.split

@@ -0,0 +1,39 @@
+// Port of TiberianSun.asl. ASL's extensionless state name is translated to
+// the current Windows host's executable name, and its string20 field is known
+// to contain localized ASCII/UTF-8 splash text.
+state "game.exe" {
+    isPlaying: u8 at "game.exe", 0x3e48fc;
+    mainMenuIndex: u8 at "game.exe", 0x408c4c;
+    gameState: u8 at "game.exe", 0x3e224c;
+    splashVisible: u8 at "game.exe", 0x34c5f4, 0x14;
+    splashText at "game.exe", 0x34c5f4, 0x14 as utf8(20);
+}
+
+isLoading {
+    return current.isPlaying == 0
+}
+
+start {
+    return old.mainMenuIndex != 0
+        && current.mainMenuIndex == 0
+        && (old.gameState == 0 || old.gameState == 30)
+        && current.gameState == 255
+}
+
+split {
+    if old.splashVisible == 0 && current.splashVisible > 0 {
+        let text = current.splashText.toAsciiLowerCase()
+        let eighth = text.slice(7, 8) else return false
+        if eighth == "c" {
+            // Spanish `MISION CUMPLIDA` pattern.
+            return true
+        }
+        if eighth != " " {
+            return false
+        }
+
+        // Common English, German, and French completion-text pattern.
+        let twelfth = text.slice(11, 12) else return false
+        return twelfth == "o"
+    }
+}

src/bin/xtask.rs

@@ -457,6 +457,13 @@ const RUNTIME_FIXTURES: &[RuntimeFixture] = &[
         harness: "tests/string_predicates_runtime.mjs",
         extra_arguments: &[],
     },
+    RuntimeFixture {
+        source: "examples/tiberian_sun.split",
+        output: "tiberian_sun.wasm",
+        profile: "release",
+        harness: "tests/tiberian_sun_runtime.mjs",
+        extra_arguments: &[],
+    },
     RuntimeFixture {
         source: "tests/while_loop.split",
         output: "while_loop.wasm",

tests/tiberian_sun_runtime.mjs

@@ -0,0 +1,139 @@
+import fs from "node:fs";
+
+const wasmPath = process.argv[2];
+if (!wasmPath) {
+    throw new Error("usage: node tests/tiberian_sun_runtime.mjs <tiberian-sun.wasm>");
+}
+
+const moduleBase = 0x10000000n;
+const splashPointer = 0x20000000n;
+const decoder = new TextDecoder();
+const encoder = new TextEncoder();
+const processNames = [];
+const moduleNames = [];
+let instance;
+let processOpen = true;
+let timerState = 0;
+let isPlaying = 1;
+let mainMenuIndex = 1;
+let gameState = 0;
+let splashVisible = 0;
+let splashText = "";
+let starts = 0;
+let splits = 0;
+let pauses = 0;
+let resumes = 0;
+let detaches = 0;
+
+const text = (pointer, length) => decoder.decode(
+    new Uint8Array(instance.exports.memory.buffer, pointer, length),
+);
+
+function writeSplash(destination) {
+    const output = new Uint8Array(instance.exports.memory.buffer, destination, 20);
+    output.fill(0);
+    const encoded = encoder.encode(splashText);
+    if (encoded.length > output.length) {
+        throw new Error(`fixture splash text exceeds string20: ${splashText}`);
+    }
+    output.set(encoded);
+}
+
+const env = {
+    timer_get_state: () => timerState,
+    timer_start() { starts += 1; timerState = 1; },
+    timer_split() { splits += 1; },
+    timer_reset() {},
+    timer_set_game_time() {},
+    timer_pause_game_time() { pauses += 1; },
+    timer_resume_game_time() { resumes += 1; },
+    timer_set_variable() {},
+    runtime_set_tick_rate() {},
+    runtime_print_message() {},
+    process_attach(pointer, length) {
+        const name = text(pointer, length);
+        processNames.push(name);
+        return name === "game.exe" ? 1n : 0n;
+    },
+    process_detach() { detaches += 1; },
+    process_is_open: () => processOpen ? 1 : 0,
+    process_get_module_address(_process, pointer, length) {
+        const name = text(pointer, length);
+        moduleNames.push(name);
+        return name === "game.exe" ? moduleBase : 0n;
+    },
+    process_read(_process, address, destination, size) {
+        const view = new DataView(instance.exports.memory.buffer);
+        if (address === moduleBase + 0x3e48fcn && size === 1) {
+            view.setUint8(destination, isPlaying);
+        } else if (address === moduleBase + 0x408c4cn && size === 1) {
+            view.setUint8(destination, mainMenuIndex);
+        } else if (address === moduleBase + 0x3e224cn && size === 1) {
+            view.setUint8(destination, gameState);
+        } else if (address === moduleBase + 0x34c5f4n && size === 8) {
+            view.setBigUint64(destination, splashPointer, true);
+        } else if (address === splashPointer + 0x14n && size === 1) {
+            view.setUint8(destination, splashVisible);
+        } else if (address === splashPointer + 0x14n && size === 20) {
+            writeSplash(destination);
+        } else {
+            throw new Error(`unexpected Tiberian Sun read ${address.toString(16)} (${size})`);
+        }
+        return 1;
+    },
+    user_settings_add_bool: () => 1,
+    user_settings_add_title() {},
+    user_settings_add_choice() {},
+    user_settings_add_choice_option: () => 0,
+    user_settings_add_file_select() {},
+    user_settings_add_file_select_name_filter() {},
+    user_settings_add_file_select_mime_filter() {},
+    user_settings_set_tooltip() {},
+    settings_map_load: () => 1n,
+    settings_map_free() {},
+    settings_map_get: () => 0n,
+    setting_value_free() {},
+    setting_value_get_bool: () => 0,
+    setting_value_get_string: () => 0,
+};
+
+({ instance } = await WebAssembly.instantiate(fs.readFileSync(wasmPath), { env }));
+instance.exports._start();
+instance.exports.update();
+
+mainMenuIndex = 0;
+gameState = 255;
+instance.exports.update();
+if (starts !== 1) throw new Error(`start transition differed: ${starts}`);
+
+isPlaying = 0;
+instance.exports.update();
+isPlaying = 1;
+instance.exports.update();
+
+splashText = "MISSION ACCOMPLISHED";
+splashVisible = 1;
+instance.exports.update();
+splashVisible = 0;
+instance.exports.update();
+splashText = "MISION CUMPLIDA";
+splashVisible = 1;
+instance.exports.update();
+splashVisible = 0;
+instance.exports.update();
+splashText = "MISSION FAILED";
+splashVisible = 1;
+instance.exports.update();
+
+if (splits !== 2 || pauses !== 1 || resumes !== 6) {
+    throw new Error(`timer behavior differed: ${JSON.stringify({ splits, pauses, resumes })}`);
+}
+if (processNames.join(",") !== "game.exe" || moduleNames.some(name => name !== "game.exe")) {
+    throw new Error(`process/module identity differed: ${JSON.stringify({ processNames, moduleNames })}`);
+}
+
+processOpen = false;
+instance.exports.update();
+if (detaches !== 1) throw new Error(`detach behavior differed: ${detaches}`);
+
+console.log(JSON.stringify({ starts, splits, pauses, resumes, detaches, moduleLookups: moduleNames.length }));