feat(web): migrate website typing runtime to Rust and Wasm

.github/workflows/oxytype-ci.yml

@@ -73,7 +73,7 @@ jobs:
               - 'packages/oxlint-config/**'
             # Workspace packages bundled into the backend and frontend.
             runtime-packages:
-              - 'packages/{challenges,contracts,funbox,schemas,typing-core,typing-engine,typing-fixtures,util}/**'
+              - 'packages/{challenges,contracts,funbox,schemas,typing-engine,typing-fixtures,util,web-shared}/**'
               - 'crates/**'
               - 'Cargo.{toml,lock}'
               - 'rust-toolchain.toml'
@@ -95,8 +95,8 @@ jobs:
               - '!**/*.md'
             backend-tests:
               - 'backend/__tests__/**'
-              # Anticheat specs replay typing-core's recorded fixtures.
-              - 'packages/typing-core/__fixtures__/**'
+              # Anticheat specs replay the immutable engine reference fixtures.
+              - 'packages/typing-fixtures/reference/**'
             # Backend test data and D1 helpers the frontend unit and SSR suites import.
             backend-test-support:
               - 'backend/__tests__/{__testData__/**,d1/helpers.ts,d1/result-support.ts}'
@@ -109,8 +109,8 @@ jobs:
             frontend-tests:
               - 'frontend/__tests__/**'
               - 'frontend/vitest.config.ts'
-              # Parity specs replay typing-core's recorded fixtures.
-              - 'packages/typing-core/__fixtures__/**'
+              # Parity specs replay the immutable engine reference fixtures.
+              - 'packages/typing-fixtures/reference/**'
               - '!frontend/__tests__/start/**'
             # Start harness: SSR suites, and the workerd fixture the browser suites serve.
             start-tests:

README.md

@@ -19,6 +19,15 @@ vp run dev
 
 The TanStack Start app, its API and local D1 run at `http://localhost:3000`.
 
+Typing rules run in the platform-independent [Rust engine](./crates/typing-engine).
+The website loads its [Wasm SDK](./packages/typing-engine/README.md) only in the
+browser; Cloudflare continues serving SSR, auth and APIs. Install the toolchain
+pinned in `rust-toolchain.toml` with its Wasm target. Build bootstrap generates the
+bindings automatically; `vp run engine:parity` checks native and built-browser
+behavior against immutable original references. `vp run engine:lint` and
+`vp run engine:fmt` check Rust. Reference provenance and measured budgets are in
+[migration progress](./docs/rust-engine/progress.md).
+
 ## Contributing
 
 See [CONTRIBUTING.md](./docs/CONTRIBUTING.md) and the [code of conduct](./docs/CODE_OF_CONDUCT.md). Report bugs in the [Oxytype repository](https://github.com/voltcrash/oxytype/issues).

backend/__tests__/anticheat/detectors.spec.ts

@@ -14,7 +14,7 @@ import {
 
 const fixtures = resolve(
   __dirname,
-  "../../../packages/typing-core/__fixtures__",
+  "../../../packages/typing-fixtures/reference",
 );
 
 function load(path: string): TimingSample[] {

backend/scripts/anticheat-calibrate.ts

@@ -22,9 +22,9 @@ recordings and synthetic fixtures are used.`;
 const root = resolve(__dirname, "../..");
 const DEFAULT_SETS: [string, string][] = [
   // scripted Playwright input against the real web client, not human typing
-  ["recorded-web", "packages/typing-core/__fixtures__/keystrokes"],
+  ["recorded-web", "packages/typing-fixtures/reference/keystrokes"],
   // label comes from each file: bot or model
-  ["", "packages/typing-core/__fixtures__/anticheat"],
+  ["", "packages/typing-fixtures/reference/anticheat"],
 ];
 
 async function files(path: string): Promise<string[]> {

crates/typing-engine-wasm/src/lib.rs

@@ -91,6 +91,28 @@ impl WasmSession {
             .ok_or_else(|| failure(ErrorCode::Disposed, "Session disposed"))?;
         serialize(&session.live_stats(now).map_err(bind_error)?)
     }
+    pub fn composition_completes(&self, data: &str) -> Result<bool, JsError> {
+        let data = parse(data)?;
+        let session = self
+            .session
+            .as_ref()
+            .ok_or_else(|| failure(ErrorCode::Disposed, "Session disposed"))?;
+        session.composition_completes(&data).map_err(bind_error)
+    }
+    pub fn can_delete(&self) -> Result<bool, JsError> {
+        let session = self
+            .session
+            .as_ref()
+            .ok_or_else(|| failure(ErrorCode::Disposed, "Session disposed"))?;
+        Ok(session.can_delete())
+    }
+    pub fn word_burst(&self, index: usize, now: f64) -> Result<f64, JsError> {
+        let session = self
+            .session
+            .as_ref()
+            .ok_or_else(|| failure(ErrorCode::Disposed, "Session disposed"))?;
+        session.word_burst(index, now).map_err(bind_error)
+    }
     pub fn snapshot(&self) -> Result<String, JsError> {
         let session = self
             .session
@@ -148,6 +170,22 @@ impl WasmContent {
             .prepare_repeating(input, repeating)
             .map_err(bind_error)
     }
+    // Reuse the existing prepared-asset envelope/parser. Only quotes, random and
+    // quote lengths participate; other preparation fields do not affect catalogs.
+    pub fn quote_catalog(&mut self, input: &str, refresh_lengths: bool) -> Result<String, JsError> {
+        let input: typing_engine::generation::Prepare = parse(input)?;
+        let asset = input
+            .quotes
+            .ok_or_else(|| failure(ErrorCode::InvalidContent, "Quote catalog asset missing"))?;
+        let lengths = refresh_lengths.then_some(input.config.quote_length);
+        let collection = self
+            .content
+            .as_mut()
+            .ok_or_else(|| failure(ErrorCode::Disposed, "Content disposed"))?
+            .quote_catalog(asset, lengths, input.random)
+            .map_err(bind_error)?;
+        serialize(&collection)
+    }
     pub fn update_quote_queue(&mut self, lengths: &str, random: &str) -> Result<String, JsError> {
         let lengths: Vec<i32> = parse(lengths)?;
         let random = parse(random)?;
@@ -170,13 +208,12 @@ impl WasmContent {
             .map_err(bind_error)
     }
     pub fn generate(&mut self, repeating: bool) -> Result<String, JsError> {
-        let generator = self
+        let generated = self
             .content
             .as_mut()
             .ok_or_else(|| failure(ErrorCode::Disposed, "Content disposed"))?
-            .generator()
+            .generate(repeating)
             .map_err(bind_error)?;
-        let generated = generator.generate(repeating).map_err(bind_error)?;
         serialize(&generated)
     }
     pub fn next(
@@ -202,9 +239,9 @@ impl WasmContent {
     pub fn metadata(&mut self) -> Result<String, JsError> {
         let generator = self
             .content
-            .as_mut()
+            .as_ref()
             .ok_or_else(|| failure(ErrorCode::Disposed, "Content disposed"))?
-            .generator()
+            .prepared_generator()
             .map_err(bind_error)?;
         serialize(
             &serde_json::json!({ "allWordsGenerated": generator.all_generated(), "currentQuote": generator.current_quote }),
@@ -213,9 +250,9 @@ impl WasmContent {
     pub fn request(&mut self) -> Result<String, JsError> {
         let generator = self
             .content
-            .as_mut()
+            .as_ref()
             .ok_or_else(|| failure(ErrorCode::Disposed, "Content disposed"))?
-            .generator()
+            .prepared_generator()
             .map_err(bind_error)?;
         serialize(&generator.pending_request())
     }

crates/typing-engine/src/analysis.rs

@@ -22,6 +22,7 @@ pub enum Query {
     Frame {
         time: f64,
     },
+    Inspect,
     CustomProgress {
         previous: u32,
     },
@@ -53,6 +54,9 @@ pub enum Response {
     Frame {
         frame: replay::Frame,
     },
+    Inspect {
+        inspection: Box<Inspection>,
+    },
     CustomProgress {
         progress: crate::custom_progress::LongProgress,
     },
@@ -67,6 +71,8 @@ pub struct Overview {
     pub input_history: Vec<Text>,
     pub corrected_words_history: Vec<Text>,
     pub missed_words: Vec<(Text, usize)>,
+    // serde_json writes positive infinity as null; the browser restores its display value.
+    #[ts(type = "Array<number | null>")]
     pub word_burst_history: Vec<f64>,
     pub raw_history: Vec<f64>,
     pub keypresses_per_second: Vec<usize>,
@@ -77,6 +83,40 @@ pub struct Overview {
     pub date_duration_ms: f64,
     pub word_indexes_per_second: Vec<Vec<usize>>,
 }
+#[derive(Serialize, TS)]
+#[serde(rename_all = "camelCase")]
+pub struct Inspection {
+    pub accuracy: stats::Accuracy,
+    pub key_spacing: Vec<f64>,
+    pub key_duration: Vec<f64>,
+    pub boundary_labels: Vec<String>,
+    pub inputs: Vec<Text>,
+    pub word_index: i32,
+}
+fn inspect(log: &Log) -> Inspection {
+    let timing = stats::key_timing(log);
+    let mut inputs = vec![Text::default(); log.context.target_words.len()];
+    let mut word_index = -1;
+    // Total observed input text is bounded before this scan. Preserve each last
+    // DOM snapshot, including legacy final-commit trim, without a second index.
+    for event in &log.events {
+        if event.kind == "input" {
+            let index = stats::word_index(event).expect("Validated input index");
+            if let Some(value) = inputs.get_mut(index) {
+                *value = stats::input_value(&event.data);
+            }
+            word_index = index as i32;
+        }
+    }
+    Inspection {
+        accuracy: stats::accuracy_counts(log, None),
+        key_spacing: timing.spacing,
+        key_duration: timing.durations,
+        boundary_labels: stats::boundary_labels(log, false),
+        inputs,
+        word_index,
+    }
+}
 pub fn analyze(log: &Log, query: Query) -> Result<Response, crate::error::EngineError> {
     crate::validation::log(log)?;
     match &query {
@@ -138,6 +178,9 @@ pub fn analyze(log: &Log, query: Query) -> Result<Response, crate::error::Engine
             steps: replay::steps(log, zen),
             duration: replay::duration(log),
         },
+        Query::Inspect => Response::Inspect {
+            inspection: Box::new(inspect(log)),
+        },
         Query::Frame { time } => Response::Frame {
             frame: replay::frame(log, time),
         },

crates/typing-engine/src/bin/export-bindings.rs

@@ -49,5 +49,6 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     typing_engine::generation::Generated::export_all(&config)?;
     typing_engine::generation::NextWord::export_all(&config)?;
     typing_engine::quotes::Quote::export_all(&config)?;
+    typing_engine::quotes::QuoteCollection::export_all(&config)?;
     Ok(())
 }

crates/typing-engine/src/content.rs

@@ -211,7 +211,10 @@ impl Queue {
         }
         let section = source.normalize(self.english)?;
         if section.words.is_empty() {
-            return Err("Section has no words".into());
+            return Err(crate::error::EngineError::new(
+                crate::error::ErrorCode::EmptyContent,
+                "Section has no words",
+            ));
         }
         self.ready.push_back(section);
         Ok(())

crates/typing-engine/src/error.rs

@@ -11,6 +11,7 @@ pub enum ErrorCode {
     Disposed,
     BindingMismatch,
     ContentRequired,
+    EmptyContent,
     StaleRequest,
     NoQuotes,
     SelectedQuoteMissing,

crates/typing-engine/src/generation.rs

@@ -37,7 +37,7 @@ pub struct NextWord {
     pub word_raw: Text,
     pub section_index: usize,
 }
-#[derive(Debug, Serialize, TS)]
+#[derive(Clone, Debug, Serialize, TS)]
 #[serde(rename_all = "camelCase")]
 pub struct Generated {
     pub words: Vec<Text>,
@@ -987,6 +987,7 @@ pub struct Prepare {
 /// Retains only explicitly owned content-selection state across restarts.
 #[derive(Default)]
 pub struct Content {
+    prepared: Option<(bool, Generated)>,
     assets: Assets,
     generator: Option<Generator>,
     weak_spot: crate::weak_spot::WeakSpot,
@@ -1008,6 +1009,29 @@ impl Content {
         self.generation = self.generation.max(memory.generation);
         self.has_prepared = true;
         self.generator = None;
+        self.prepared = None;
+    }
+    pub fn quote_catalog(
+        &mut self,
+        asset: crate::quotes::QuoteAsset,
+        lengths: Option<Vec<i32>>,
+        mut random: Random,
+    ) -> Result<crate::quotes::QuoteCollection, EngineError> {
+        crate::validation::random(&random)?;
+        if lengths.as_ref().is_some_and(|lengths| {
+            lengths.len() > 64
+                || lengths
+                    .iter()
+                    .any(|length| ![-3, -2, 0, 1, 2, 3].contains(length))
+        }) {
+            return Err(EngineError::new(
+                ErrorCode::InvalidConfig,
+                "Invalid quote length selection",
+            ));
+        }
+        self.assets
+            .quotes
+            .load_catalog(asset, lengths.as_deref(), &mut random)
     }
     pub fn update_quote_queue(
         &mut self,
@@ -1047,6 +1071,7 @@ impl Content {
         }
         self.has_prepared = true;
         self.generator = None;
+        self.prepared = None;
         self.assets.quote_asset = input.quotes;
         self.assets.polyglot = input.polyglot;
         self.assets.selected_quote_id = input.selected_quote_id;
@@ -1077,13 +1102,27 @@ impl Content {
         &mut self,
         repeating: bool,
     ) -> Result<crate::Session, crate::error::EngineError> {
-        let generated = self.generator()?.generate(repeating)?;
+        let generated = match self.prepared.take() {
+            Some((prepared_repeat, generated)) if prepared_repeat == repeating => generated,
+            _ => self.generator()?.generate(repeating)?,
+        };
         let generator = self.generator.take().ok_or("Content not prepared")?;
         let mut session = crate::Session::from_generated(generator, generated)?;
         session.pace.remember(self.last_pace_wpm, false);
         Ok(session)
     }
-    pub fn generator(&mut self) -> Result<&mut Generator, crate::error::EngineError> {
+    /// Inspect prepared output without restarting generation or consuming RNG/source content.
+    pub fn generate(&mut self, repeating: bool) -> Result<Generated, EngineError> {
+        let generated = self.generator()?.generate(repeating)?;
+        self.prepared = Some((repeating, generated.clone()));
+        Ok(generated)
+    }
+    pub fn prepared_generator(&self) -> Result<&Generator, EngineError> {
+        self.generator.as_ref().ok_or("Content not prepared".into())
+    }
+    /// Mutable generator access invalidates any prior presentation snapshot.
+    pub fn generator(&mut self) -> Result<&mut Generator, EngineError> {
+        self.prepared = None;
         self.generator.as_mut().ok_or("Content not prepared".into())
     }
 }