feat: parallel web solving

.gitea/scripts/push-image.sh

@@ -1,22 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-REGISTRY="${REGISTRY#https://}"
-REGISTRY="${REGISTRY#http://}"
-REGISTRY="${REGISTRY%/}"
-
-IMAGE="${REGISTRY}/${REPOSITORY}:${TAG}"
-
-echo "Pushing ${IMAGE}"
-
-skopeo copy \
-  --dest-creds "${USERNAME}:${PASSWORD}" \
-  "docker-archive:result" \
-  "docker://${IMAGE}"
-
-if [ "${REF_NAME:-}" = "main" ]; then
-  skopeo copy \
-    --dest-creds "${USERNAME}:${PASSWORD}" \
-    "docker-archive:result" \
-    "docker://${REGISTRY}/${REPOSITORY}:latest"
-fi

.gitea/workflows/docker.yaml

@@ -1,47 +0,0 @@
-name: Build docker images.
-
-on:
-  push:
-
-jobs:
-  build-wordle-solver-image:
-    runs-on: nixos
-
-    steps:
-      - name: Check out repository code
-        uses: actions/checkout@v4
-
-      - name: Build wordle-solver image
-        run: |
-          nix build .#wordle-solver-docker
-
-      - name: Push image
-        env:
-          REGISTRY: "${{ gitea.server_url }}"
-          REPOSITORY: "${{ gitea.repository }}"
-          USERNAME: "${{ secrets.REGISTRY_USER }}"
-          PASSWORD: "${{ secrets.REGISTRY_TOKEN }}"
-          REF_NAME: "${{ gitea.ref_name }}"
-          TAG: "${{ gitea.sha }}"
-        run: bash .gitea/scripts/push-image.sh
-
-  build-wordle-solver-web-image:
-    runs-on: nixos
-
-    steps:
-      - name: Check out repository code
-        uses: actions/checkout@v4
-
-      - name: Build wordle-solver-web image
-        run: |
-          nix build .#wordle-solver-web-docker
-
-      - name: Push image
-        env:
-          REGISTRY: "${{ gitea.server_url }}"
-          REPOSITORY: "${{ gitea.repository }}-web"
-          USERNAME: "${{ secrets.REGISTRY_USER }}"
-          PASSWORD: "${{ secrets.REGISTRY_TOKEN }}"
-          REF_NAME: "${{ gitea.ref_name }}"
-          TAG: "${{ gitea.sha }}"
-        run: bash .gitea/scripts/push-image.sh

Cargo.lock

@@ -8,6 +8,12 @@ version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "23b62fc65de8e4e7f52534fb52b0f3ed04746ae267519eef2a83941e8085068b"
 
+[[package]]
+name = "autocfg"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
+
 [[package]]
 name = "bumpalo"
 version = "3.20.3"
@@ -114,7 +120,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "rustc_version",
- "syn",
+ "syn 2.0.119",
  "unicode-xid",
 ]
 
@@ -199,6 +205,15 @@ version = "0.2.189"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"
 
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
 [[package]]
 name = "once_cell"
 version = "1.21.4"
@@ -278,6 +293,25 @@ dependencies = [
  "crossbeam-utils",
 ]
 
+[[package]]
+name = "rmp"
+version = "0.8.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ba8be72d372b2c9b35542551678538b562e7cf86c3315773cae48dfbfe7790c"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "rmp-serde"
+version = "1.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72f81bee8c8ef9b577d1681a70ebbc962c232461e397b22c208c43c04b67a155"
+dependencies = [
+ "rmp",
+ "serde",
+]
+
 [[package]]
 name = "rustc_version"
 version = "0.4.1"
@@ -299,6 +333,36 @@ version = "1.0.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
 
+[[package]]
+name = "serde"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.3",
+]
+
 [[package]]
 name = "slab"
 version = "0.4.12"
@@ -325,6 +389,17 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "syn"
+version = "3.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53e9bae58849f64dfa4f5d5ae372c8341f7305f82a3868709269343628b659a3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
 [[package]]
 name = "tabular"
 version = "0.2.0"
@@ -430,7 +505,7 @@ dependencies = [
  "bumpalo",
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.119",
  "wasm-bindgen-shared",
 ]
 
@@ -479,6 +554,8 @@ dependencies = [
  "js-sys",
  "rand",
  "rayon",
+ "rmp-serde",
+ "serde",
  "tabular",
  "wasm-bindgen",
 ]

Cargo.toml

@@ -27,9 +27,11 @@ indicatif = { version = "0.18.6", features = ["rayon"] }
 js-sys = { version = "0.3.104", optional = true }
 rand = "0.10.2"
 rayon = "1.12.0"
+rmp-serde = { version = "1.3.1", optional = true }
+serde = { version = "1.0.229", optional = true, features = ["derive"] }
 tabular = { version = "0.2.0", features = ["ansi-cell"] }
 wasm-bindgen = { version = "0.2.127", optional = true }
 
 [features]
 default = []
-wasm-bindgen = ["dep:wasm-bindgen", "getrandom/wasm_js", "dep:js-sys"]
+wasm-bindgen = ["dep:wasm-bindgen", "getrandom/wasm_js", "dep:js-sys", "dep:serde", "dep:rmp-serde"]

README.md

@@ -1,60 +0,0 @@
-# Wordle Solver
-
-This wordle solver uses an information theory based approach to evaluate the next-best-guess. It's heavily inspired by [3b1b's approach](https://www.youtube.com/watch?v=v68zYyaEmEA) on solving wordle.
-
-There are two ways to use the wordle-solver.
-
-1. a CLI tool
-2. a web interface
-
-
-# Docker
-
-#### CLI
-```sh
-docker run --rm -it git.jroeger.de/jonas/wordle-solver-rs 
-```
-
-#### web
-``` sh
-docker run -p 8080:80 --rm -it git.jroeger.de/jonas/wordle-solver-rs-web
-```
-
-# Nix
-
-#### CLI
-
-``` sh
-nix run .
-```
-
-#### Static web site
-
-``` sh
-nix build git+http://git.jroeger.de/jonas/wordle-solver-rs#wordle-solver-web
-```
-
-# Native
-
-#### CLI
-
-you will need to have `cargo` installed.
-
-```sh
-cargo run --profile release
-```
-
-#### web
-
-you need the following tools:
-- `wasm-pack`
-- `wasm-bindgen`
-- `cargo`
-- `nodejs`
-- `yarn`
-
-``` sh
-cd web
-yarn install
-yarn serve # or yarn build
-```

flake.nix

@@ -16,6 +16,7 @@
 
   outputs = inputs @ {
     flake-parts,
+    crate2nix,
     rust-overlay,
     ...
   }:
@@ -27,24 +28,33 @@
         "x86_64-linux"
       ];
 
-      imports = [
-        ./nix/wasm-bindgen.nix
-        ./nix/wordle-solver-docker.nix
-        ./nix/wordle-solver-wasm-pkg.nix
-        ./nix/wordle-solver-wasm.nix
-        ./nix/wordle-solver-web-docker.nix
-        ./nix/wordle-solver-web.nix
-        ./nix/wordle-solver.nix
-      ];
-
       perSystem = {
         pkgs,
         system,
         self',
         ...
       }: let
-        utils = import ./nix/utils.nix;
+        # Use rust-bin to generate the toolchain from rust-toolchain.toml
-        rust-toolchain = utils.rust-toolchain pkgs;
+        rust-toolchain = pkgs.rust-bin.fromRustupToolchainFile ./rust-toolchain.toml;
+
+        cross-pkgs = pkgs.pkgsCross.wasm32-unknown-none;
+
+        toolchain = pkgs.callPackage ./nix/with-toolchain.nix {
+          cargo = rust-toolchain;
+          rustc = rust-toolchain;
+        };
+        crossToolchain = cross-pkgs.callPackage ./nix/with-toolchain.nix {
+          cargo = rust-toolchain;
+          rustc = rust-toolchain;
+        };
+
+        wasm-bindgen = toolchain.pkgs.callPackage ./nix/wasm-bindgen.nix {};
+
+        root-crate = pkgs.callPackage ./nix/root-crate.nix {
+          cargo = rust-toolchain;
+          rustc = rust-toolchain;
+          inherit crate2nix;
+        };
       in {
         # Overlay pkgs with rust-bin
         _module.args.pkgs = import inputs.nixpkgs {
@@ -53,13 +63,22 @@
           config.allowUnsupportedSystem = true;
         };
 
-        packages.default = self'.packages.wordle-solver;
+        packages = {
+          wordle-solver-web = pkgs.callPackage ./nix/wordle-solver-web.nix {inherit (self'.packages) wordle-solver-wasm-pkg;};
+          wordle-solver-wasm = crossToolchain.pkgs.callPackage ./nix/wordle-solver-wasm.nix {};
+          wordle-solver-wasm-pkg = pkgs.callPackage ./nix/wordle-solver-wasm-pkg.nix {
+            inherit wasm-bindgen root-crate;
+            inherit (self'.packages) wordle-solver-wasm;
+          };
+          wordle-solver = root-crate.build;
+          default = self'.packages.wordle-solver;
+        };
 
         devShells.default = pkgs.mkShell {
           RA_LOG = "rust_analyzer=info";
           buildInputs = [
             rust-toolchain
-            self'.packages.wasm-bindgen
+            wasm-bindgen
             pkgs.nodejs
             pkgs.svelte-language-server
             pkgs.typescript-language-server

nix/root-crate.nix

@@ -0,0 +1,23 @@
+{
+  crate2nix,
+  rustc,
+  cargo,
+  pkgs,
+  ...
+}: let
+  buildRustCrateForPkgs = _:
+    pkgs.buildRustCrate.override {
+      inherit cargo rustc;
+    };
+
+  # Cargo.nix for IFD
+  generatedCargoNix = crate2nix.tools.${pkgs.hostPlatform.system}.generatedCargoNix {
+    name = "rustnix";
+    src = ../.;
+  };
+
+  cargoNix = import generatedCargoNix {
+    inherit pkgs buildRustCrateForPkgs;
+  };
+in
+  cargoNix.rootCrate

nix/utils.nix

@@ -1,21 +0,0 @@
-rec {
-  rust-toolchain = pkgs: pkgs.rust-bin.fromRustupToolchainFile ../rust-toolchain.toml;
-
-  toolchain-pkgs = pkgs:
-    pkgs.extend (_: _: {
-      rustPlatform = pkgs.makeRustPlatform {
-        cargo = rust-toolchain pkgs;
-        rustc = rust-toolchain pkgs;
-      };
-    });
-
-  toolchain-crosspkgs = pkgs: let
-    crossPkgs = pkgs.pkgsCross.wasm32-unknown-none;
-  in
-    crossPkgs.extend (_: _: {
-      rustPlatform = crossPkgs.makeRustPlatform {
-        cargo = rust-toolchain pkgs;
-        rustc = rust-toolchain pkgs;
-      };
-    });
-}

nix/wasm-bindgen.nix

@@ -1,11 +1,10 @@
-let
+{
-  drv = {
   fetchCrate,
   buildWasmBindgenCli,
   rustPlatform,
   ...
-  }:
+}:
-    buildWasmBindgenCli rec {
+buildWasmBindgenCli rec {
   src = fetchCrate {
     pname = "wasm-bindgen-cli";
     version = "0.2.127";
@@ -17,11 +16,4 @@ let
     inherit (src) pname version;
     hash = "sha256-FTv2GZIAQs0ePdIZXIXil7JbZ6kIT05VG6vqC1qNFxQ=";
   };
-    };
-
-  utils = import ./utils.nix;
-in {
-  perSystem = {pkgs, ...}: {
-    packages.wasm-bindgen = (utils.toolchain-pkgs pkgs).callPackage drv {};
-  };
 }

nix/with-toolchain.nix

@@ -0,0 +1,16 @@
+{
+  makeRustPlatform,
+  cargo,
+  rustc,
+  pkgs,
+  ...
+}: let
+  p = pkgs;
+in rec {
+  rustPlatform = makeRustPlatform {
+    inherit cargo rustc;
+  };
+  pkgs = p.extend (_: _: {
+    inherit rustPlatform;
+  });
+}

nix/wordle-solver-docker.nix

@@ -1,39 +0,0 @@
-let
-  drv = {
-    buildEnv,
-    dockerTools,
-    wordle-solver,
-    runCommand,
-    ...
-  }:
-    dockerTools.buildImage {
-      name = "wordle-solver";
-      created = "now";
-      copyToRoot = buildEnv {
-        name = "image-root";
-        paths = [
-          wordle-solver
-          (runCommand "wordle-data" {} ''
-            mkdir -p $out/pwd
-            cp ${../valid-words.txt} $out/pwd/valid-words.txt
-            cp ${../answers.txt} $out/pwd/answers.txt
-          '')
-        ];
-        pathsToLink = ["/bin" "/pwd"];
-      };
-      config = {
-        Cmd = ["/bin/wordle-solver"];
-        WorkingDir = "/pwd";
-      };
-    };
-in {
-  perSystem = {
-    pkgs,
-    self',
-    ...
-  }: {
-    packages.wordle-solver-docker = pkgs.callPackage drv {
-      inherit (self'.packages) wordle-solver;
-    };
-  };
-}

nix/wordle-solver-wasm-pkg.nix

@@ -1,21 +1,16 @@
 {
-  perSystem = {
-    pkgs,
-    self',
-    ...
-  }: let
-    drv = {
   stdenvNoCC,
   wasm-bindgen,
   wordle-solver-wasm,
+  root-crate,
   ...
-    }: let
+}: let
   snake_name = "wordle_solver";
   package-meta = {
     name = "wordle-solver";
     type = "module";
     description = "module";
-        version = "0.1.0";
+    version = root-crate.build.crateVersion;
     files = [
       "${snake_name}_bg.wasm"
       "${snake_name}.js"
@@ -30,7 +25,7 @@
     ];
   };
   package-json = builtins.toJSON package-meta;
-    in
+in
   stdenvNoCC.mkDerivation {
     name = "wordle-solver-wasm-pkg";
     nativeBuildInputs = [wasm-bindgen];
@@ -41,10 +36,4 @@
       ${package-json}
       EOF
     '';
-      };
+  }
-  in {
-    packages.wordle-solver-wasm-pkg = pkgs.callPackage drv {
-      inherit (self'.packages) wordle-solver-wasm wasm-bindgen;
-    };
-  };
-}

nix/wordle-solver-wasm.nix

@@ -1,17 +1,11 @@
 {
-  perSystem = {pkgs, ...}: let
-    utils = import ./utils.nix;
-    rust-toolchain = utils.rust-toolchain pkgs;
-    toolchain-crosspkgs = utils.toolchain-crosspkgs pkgs;
-    drv = {
   rustPlatform,
   buildPackages,
   lld,
   name ? "wordle-solver",
-      removeReferencesTo,
   ...
-    }:
+}:
-      rustPlatform.buildRustPackage {
+rustPlatform.buildRustPackage {
   inherit name;
 
   src = ../.; # Or your source location
@@ -25,7 +19,6 @@
     buildPackages.stdenv.cc
     lld # Needed for wasm-ld
   ];
-        nativeBuildInputs = [removeReferencesTo];
 
   cargoBuildFlags = [
     "--lib"
@@ -34,23 +27,13 @@
   ];
 
   # Configure rustc for WASM
-        RUSTFLAGS = ''--cfg=web_sys_unstable_apis -C linker=wasm-ld -C strip=debuginfo -C debuginfo=0'';
+  env = {
+    RUSTFLAGS = ''--cfg=web_sys_unstable_apis -C linker=wasm-ld'';
+  };
 
   # Copy the WASM file to the output
   installPhase = ''
     mkdir -p $out/lib
     cp target/wasm32-unknown-unknown/release/*.wasm $out/lib/
-
-          runHook postInstall
   '';
-
-        # Remove toolchain from closure (store paths are debug artifacts)
-        postInstall = ''
-          remove-references-to -t ${rust-toolchain} $out/lib/*.wasm
-        '';
-      };
-  in {
-    packages.toolchain = rust-toolchain;
-    packages.wordle-solver-wasm = toolchain-crosspkgs.callPackage drv {};
-  };
 }

nix/wordle-solver-web-docker.nix

@@ -1,64 +0,0 @@
-let
-  drv = {
-    buildEnv,
-    dockerTools,
-    fakeNss,
-    nginx,
-    runCommand,
-    wordle-solver-web,
-    ...
-  }:
-    dockerTools.buildImage {
-      name = "wordle-solver-web";
-      created = "now";
-      copyToRoot = buildEnv {
-        name = "image-root";
-        paths = [
-          nginx
-          (fakeNss.override {
-            extraGroupLines = [
-              "nogroup:x:65534:"
-            ];
-          })
-          (runCommand "nginx-conf" {} ''
-            mkdir -p $out/etc
-
-            cat <<EOF > $out/etc/nginx.conf
-            events {}
-
-            error_log /dev/stderr;
-
-            http {
-                include ${nginx}/conf/mime.types;
-
-                server {
-                        listen 80;
-                        root ${wordle-solver-web};
-                        access_log /dev/stdout;
-                }
-            }
-
-            daemon off;
-            EOF
-          '')
-        ];
-        pathsToLink = ["/etc"];
-      };
-      runAsRoot = ''
-        mkdir -p /var/log/nginx
-      '';
-      config = {
-        Cmd = ["${nginx}/bin/nginx" "-c" "/etc/nginx.conf"];
-      };
-    };
-in {
-  perSystem = {
-    pkgs,
-    self',
-    ...
-  }: {
-    packages.wordle-solver-web-docker = pkgs.callPackage drv {
-      inherit (self'.packages) wordle-solver-web;
-    };
-  };
-}

nix/wordle-solver-web.nix

@@ -1,18 +1,12 @@
 {
-  perSystem = {
-    pkgs,
-    self',
-    ...
-  }: let
-    drv = {
   stdenv,
   fetchYarnDeps,
   yarnConfigHook,
   yarnBuildHook,
   nodejs,
   wordle-solver-wasm-pkg,
-    }:
+}:
-      stdenv.mkDerivation (finalAttrs: {
+stdenv.mkDerivation (finalAttrs: {
   pname = "wordle-solver-web";
   version = "0.1.0";
 
@@ -40,10 +34,4 @@
     # Needed for executing package.json scripts
     nodejs
   ];
-      });
+})
-  in {
-    packages.wordle-solver-web = pkgs.callPackage drv {
-      inherit (self'.packages) wordle-solver-wasm-pkg;
-    };
-  };
-}

nix/wordle-solver.nix

@@ -1,27 +0,0 @@
-{inputs, ...}: {
-  perSystem = {pkgs, ...}: let
-    # Cargo.nix for IFD
-    generatedCargoNix = inputs.crate2nix.tools.${pkgs.hostPlatform.system}.generatedCargoNix {
-      name = "rustnix";
-      src = ../.;
-    };
-
-    utils = import ./utils.nix;
-
-    rust-toolchain = utils.rust-toolchain pkgs;
-    toolchain-pkgs = utils.toolchain-pkgs pkgs;
-
-    buildRustCrateForPkgs = _:
-      pkgs.buildRustCrate.override {
-        cargo = rust-toolchain;
-        rustc = rust-toolchain;
-      };
-
-    cargoNix = import generatedCargoNix {
-      pkgs = toolchain-pkgs;
-      inherit buildRustCrateForPkgs;
-    };
-  in {
-    packages.wordle-solver = cargoNix.rootCrate.build;
-  };
-}

src/lib/pattern.rs

@@ -1,7 +1,10 @@
 use colored::Colorize;
 use derive_more::Display;
+#[cfg(feature = "wasm-bindgen")]
+use serde::{Deserialize, Serialize};
 
 #[derive(Display, Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Hash)]
+#[cfg_attr(feature = "wasm-bindgen", derive(Serialize, Deserialize))]
 pub enum CharStatus {
     GREY,
     YELLOW,
@@ -9,6 +12,7 @@ pub enum CharStatus {
 }
 
 #[derive(Debug, PartialEq, Eq, Hash, Clone)]
+#[cfg_attr(feature = "wasm-bindgen", derive(Serialize, Deserialize))]
 pub struct Pattern {
     chars: Vec<char>,
     stats: Vec<CharStatus>,

src/lib/solver.rs

@@ -7,18 +7,23 @@ use crate::pattern::Pattern;
 use indicatif::ParallelProgressIterator;
 use rayon::iter::{ParallelBridge, ParallelIterator};
 
+#[cfg(feature = "wasm-bindgen")]
+use serde::{Deserialize, Serialize};
+
 use crate::word_list::WordList;
 
 use derive_more::Display;
 use tabular::{Row, Table};
 
 #[derive(Clone)]
+#[cfg_attr(feature = "wasm-bindgen", derive(Serialize, Deserialize))]
 pub struct Guess {
     pub pattern: Pattern,
     pub information_gained: f64,
 }
 
 #[derive(Clone)]
+#[cfg_attr(feature = "wasm-bindgen", derive(Serialize, Deserialize))]
 pub struct Solver {
     valid_words: WordList,
     possible_solutions: WordList,

src/lib/wasm.rs

@@ -1,5 +1,7 @@
 use std::io;
 
+use rmp_serde::{from_slice, to_vec};
+use serde::Serialize;
 use wasm_bindgen::prelude::*;
 
 use crate::{
@@ -63,6 +65,26 @@ impl Solver {
         }
     }
 
+    pub fn serialize(&self) -> Result<js_sys::Uint8Array, String> {
+        let r = to_vec(&self.0).map_err(|e| {
+            let s = e.to_string();
+            drop(e);
+            s
+        })?;
+
+        Ok(js_sys::Uint8Array::from(&r[..]))
+    }
+
+    pub fn new_from_serialized(bytes: &js_sys::Uint8Array) -> Result<Solver, String> {
+        from_slice(&bytes.to_vec()[..])
+            .map_err(|e| {
+                let s = e.to_string();
+                drop(e);
+                s
+            })
+            .map(Solver)
+    }
+
     pub fn guess(&mut self, word: &str, colors: Vec<Color>) -> Result<(), String> {
         let pat = Pattern::try_new(
             word,

src/lib/word_list.rs

@@ -1,4 +1,6 @@
 use rand::{rng, seq::IteratorRandom};
+#[cfg(feature = "wasm-bindgen")]
+use serde::{Deserialize, Serialize};
 use std::{
     collections::{hash_set, HashSet},
     fs::{self},
@@ -11,6 +13,7 @@ use derive_more::Display;
 use crate::pattern::Pattern;
 
 #[derive(Display, Clone)]
+#[cfg_attr(feature = "wasm-bindgen", derive(Serialize, Deserialize))]
 #[display("{:?}", words)]
 pub struct WordList {
     words: HashSet<String>,

web/package.json

@@ -4,14 +4,13 @@
   "version": "0.0.0",
   "type": "module",
   "scripts": {
-    "serve": "run-s wasm-pack:release vite:serve",
     "build-no-wasm": "run-s tsc vite:build",
     "build": "run-s wasm-pack:release tsc vite:build",
     "dev": "run-s wasm-pack:dev vite:dev",
     "tsc": "tsc",
     "vite:build": "vite build",
     "vite:dev": "vite -c vite.config.dev.ts",
-    "vite:serve": "vite -c vite.config.ts",
+    "vite:preview": "vite preview",
     "wasm-pack:dev": "rm -rf pkg; wasm-pack build --dev --features wasm-bindgen --manifest-path ../Cargo.toml; mv ../pkg .",
     "wasm-pack:release": "rm -rf pkg; wasm-pack build --features wasm-bindgen --manifest-path ../Cargo.toml; mv ../pkg ."
   },

web/src/App.svelte

@@ -6,6 +6,7 @@
         solver_guess,
         solver_reset,
         solver_solution_space,
+        solver_stop,
     } from "./solver/solver.ts";
     import type {
         GuessResult,
@@ -93,12 +94,7 @@
     }
 
     async function stopSolver() {
-        await solver_reset(use_default_wordle_answers);
+        await solver_stop();
-        for (const g of guesses.slice(0, -1)) {
-            try {
-                await solver_guess(g.letters, g.colors);
-            } catch (_) {}
-        }
     }
 
     async function doGuess() {

web/src/solver/solver.ts

@@ -1,9 +1,6 @@
 import type { Color } from "wordle-solver";
 import SolverWorker from "./worker?worker";
-import type { GuessResult, SolutionSpaceResult, EvaluateWordsResult, SolverRequest, SolverResponse, EvaluateWordsProgress } from "./types";
+import type { GuessResult, SolutionSpaceResult, EvaluateWordsResult, SolverRequest, SolverResponse, EvaluateWordsProgress, SolverStateResult, RestoreSolverState } from "./types";
-
-let solver_worker = new SolverWorker();
-await init_solver();
 
 let msg_id = 0;
 
@@ -14,6 +11,12 @@ const pending = new Map<number, {
 
 const progresses = new Map<number, (p: EvaluateWordsProgress) => void>();
 
+let solver_worker = new SolverWorker();
+await init_solver();
+
+let last_solver_state = await solver_state();
+
+
 function init_solver(): Promise<void> {
   return new Promise((resolve) => {
     solver_worker.onmessage = (event: any) => {
@@ -65,13 +68,15 @@ export function solver_solution_space(): Promise<SolutionSpaceResult> {
   });
 }
 
-export function solver_evaluate_words(n: number, progress: ((p: EvaluateWordsProgress) => void) | null): Promise<EvaluateWordsResult> {
+export async function solver_evaluate_words(n: number, progress: ((p: EvaluateWordsProgress) => void) | null): Promise<EvaluateWordsResult> {
   const id = msg_id++;
 
   if (progress) {
     progresses.set(id, progress);
   }
 
+  last_solver_state = await solver_state();
+
   return new Promise((resolve, reject) => {
     pending.set(id, { resolve, reject });
 
@@ -85,6 +90,52 @@ export function solver_evaluate_words(n: number, progress: ((p: EvaluateWordsPro
   });
 }
 
+function solver_state(): Promise<SolverStateResult> {
+  const id = msg_id++;
+
+  return new Promise((resolve, reject) => {
+    pending.set(id, { resolve, reject });
+
+    const r: SolverRequest = {
+      type: "solver_state",
+      id: id,
+      input: null,
+    };
+
+    solver_worker.postMessage(JSON.parse(JSON.stringify(r)));
+  });
+}
+
+function restore_solver_state(s: RestoreSolverState): Promise<void> {
+  const id = msg_id++;
+
+  return new Promise((resolve, reject) => {
+    pending.set(id, { resolve, reject });
+
+    const r: SolverRequest = {
+      type: "restore_solver_state",
+      id: id,
+      input: s,
+    };
+
+    solver_worker.postMessage(r);
+  });
+}
+
+export async function solver_stop(): Promise<void> {
+  solver_worker.terminate();
+
+  pending.forEach((v, _) => {
+    v.reject("Solver was stopped");
+  });
+  pending.clear();
+  progresses.clear();
+
+  await create_solver_worker();
+
+  await restore_solver_state(last_solver_state);
+}
+
 export async function solver_reset(wordle_answers: boolean): Promise<void> {
   solver_worker.terminate();
 

web/src/solver/types.ts

@@ -20,8 +20,19 @@ export type SolverRequest =
     type: "reload_wordlist",
     id: number,
     input: ReloadWordlist
+  }
+  | {
+    type: "solver_state",
+    id: number,
+    input: null
+  }
+  | {
+    type: "restore_solver_state",
+    id: number,
+    input: RestoreSolverState
   };
 
+
 export type SolverResponse =
   | {
     type: "guess",
@@ -52,8 +63,21 @@ export type SolverResponse =
     id: number,
     error: string | null
     result: boolean | null,
+  }
+  | {
+    type: "solver_state",
+    id: number,
+    error: string | null
+    result: SolverStateResult | null,
+  }
+  | {
+    type: "restore_solver_state",
+    id: number,
+    error: string | null
+    result: boolean | null,
   };
 
+
 export type Guess = {
   word: string[],
   colors: Color[]
@@ -84,3 +108,9 @@ export type SolutionSpaceResult = {
   size: number,
   uncertainty: number
 };
+export type SolverStateResult = {
+  raw: Uint8Array
+};
+export type RestoreSolverState = {
+  raw: Uint8Array
+};

web/src/solver/worker.ts

@@ -99,6 +99,40 @@ self.onmessage = (event: MessageEvent<SolverRequest>) => {
       self.postMessage(JSON.parse(JSON.stringify(response)));
       break;
     };
+    case "solver_state": {
+      let response: SolverResponse = {
+        type: "solver_state",
+        id: request.id,
+        error: null,
+        result: null
+      };
+      try {
+        response.result = { raw: solver.serialize() };
+      } catch (e) {
+        response.error = e as string;
+      }
+
+      self.postMessage(response);
+      break;
+    };
+    case "restore_solver_state": {
+      let response: SolverResponse = {
+        type: "restore_solver_state",
+        id: request.id,
+        error: null,
+        result: null
+      };
+      try {
+        solver.free();
+        solver = Solver.new_from_serialized(request.input.raw);
+        response.result = true;
+      } catch (e) {
+        response.error = e as string;
+      }
+
+      self.postMessage(response);
+      break;
+    }
   }
 };