Merge branch 'main' into descriptive_launcher

.buildkite/linux/entrypoint

@@ -16,6 +16,7 @@ if [ "$CLEAR_RUST" = "1" ]; then
     rm -rf $BUILD_ROOT/rust
 fi
 
+rm -f out/build.ninja
 ./ninja pylib qt check
 
 echo "--- Ensure libs importable"

CONTRIBUTORS

@@ -243,6 +243,10 @@ Lee Doughty <32392044+leedoughty@users.noreply.github.com>
 memchr <memchr@proton.me>
 Max Romanowski <maxr777@proton.me>
 Aldlss <ayaldlss@gmail.com>
+Hanna Nilsén <hanni614@student.liu.se>
+Elias Johansson Lara <elias.johanssonlara@gmail.com>
+Toby Penner <tobypenner01@gmail.com>
+Danilo Spillebeen <spillebeendanilo@gmail.com>
 
 ********************
 

Cargo.lock

@@ -3555,6 +3555,7 @@ dependencies = [
 name = "launcher"
 version = "1.0.0"
 dependencies = [
+ "anki_i18n",
  "anki_io",
  "anki_process",
  "anyhow",
@@ -3563,6 +3564,7 @@ dependencies = [
  "embed-resource",
  "libc",
  "libc-stdhandle",
+ "locale_config",
  "serde_json",
  "widestring",
  "windows 0.61.3",
@@ -3702,6 +3704,19 @@ version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f5e54036fe321fd421e10d732f155734c4e4afd610dd556d9a82833ab3ee0bed"
 
+[[package]]
+name = "locale_config"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08d2c35b16f4483f6c26f0e4e9550717a2f6575bcd6f12a53ff0c490a94a6934"
+dependencies = [
+ "lazy_static",
+ "objc",
+ "objc-foundation",
+ "regex",
+ "winapi",
+]
+
 [[package]]
 name = "lock_api"
 version = "0.4.13"
@@ -4380,6 +4395,26 @@ dependencies = [
  "malloc_buf",
 ]
 
+[[package]]
+name = "objc-foundation"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1add1b659e36c9607c7aab864a76c7a4c2760cd0cd2e120f3fb8b952c7e22bf9"
+dependencies = [
+ "block",
+ "objc",
+ "objc_id",
+]
+
+[[package]]
+name = "objc_id"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c92d4ddb4bd7b50d730c215ff871754d0da6b2178849f8a2a2ab69712d0c073b"
+dependencies = [
+ "objc",
+]
+
 [[package]]
 name = "object"
 version = "0.36.7"

Cargo.toml

@@ -92,6 +92,7 @@ itertools = "0.14.0"
 junction = "1.2.0"
 libc = "0.2"
 libc-stdhandle = "0.1"
+locale_config = "0.3.0"
 maplit = "1.0.2"
 nom = "8.0.0"
 num-format = "0.4.4"

cargo/licenses.json

@@ -2226,7 +2226,7 @@
   {
     "authors": "Ibraheem Ahmed <ibraheem@ibraheem.ca>",
     "description": "A high performance, zero-copy URL router.",
-    "license": "MIT AND BSD-3-Clause",
+    "license": "BSD-3-Clause AND MIT",
     "license_file": null,
     "name": "matchit",
     "repository": "https://github.com/ibraheemdev/matchit"
@@ -4154,7 +4154,7 @@
   {
     "authors": "David Tolnay <dtolnay@gmail.com>",
     "description": "Determine whether characters have the XID_Start or XID_Continue properties according to Unicode Standard Annex #31",
-    "license": "(MIT OR Apache-2.0) AND Unicode-3.0",
+    "license": "(Apache-2.0 OR MIT) AND Unicode-3.0",
     "license_file": null,
     "name": "unicode-ident",
     "repository": "https://github.com/dtolnay/unicode-ident"

ftl/core-repo

@@ -1 +1 @@
-Subproject commit 480ef0da728c7ea3485c58529ae7ee02be3e5dba
+Subproject commit ec5e4cad6242e538cacf52265243668f0de5da80

ftl/core/launcher.ftl

@@ -0,0 +1,37 @@
+launcher-title = Anki Launcher
+launcher-press-enter-to-start = Press enter to start Anki.
+launcher-anki-will-start-shortly = Anki will start shortly.
+launcher-you-can-close-this-window = You can close this window.
+launcher-updating-anki = Updating Anki...
+launcher-latest-anki = Latest Anki (just press Enter)
+launcher-choose-a-version = Choose a version
+launcher-sync-project-changes = Sync project changes
+launcher-keep-existing-version = Keep existing version ({ $current })
+launcher-revert-to-previous = Revert to previous version ({ $prev })
+launcher-allow-betas = Allow betas: { $state }
+launcher-on = on
+launcher-off = off
+launcher-cache-downloads = Cache downloads: { $state }
+launcher-download-mirror = Download mirror: { $state }
+launcher-uninstall = Uninstall
+launcher-invalid-input = Invalid input. Please try again.
+launcher-latest-releases = Latest releases: { $releases }
+launcher-enter-the-version-you-want = Enter the version you want to install:
+launcher-versions-before-cant-be-installed = Versions before 2.1.50 can't be installed.
+launcher-invalid-version = Invalid version.
+launcher-unable-to-check-for-versions = Unable to check for Anki versions. Please check your internet connection.
+launcher-checking-for-updates = Checking for updates...
+launcher-uninstall-confirm = Uninstall Anki's program files? (y/n)
+launcher-uninstall-cancelled = Uninstall cancelled.
+launcher-program-files-removed = Program files removed.
+launcher-remove-all-profiles-confirm = Remove all profiles/cards? (y/n)
+launcher-user-data-removed = User data removed.
+launcher-download-mirror-options = Download mirror options:
+launcher-mirror-no-mirror = No mirror
+launcher-mirror-china = China
+launcher-mirror-disabled = Mirror disabled.
+launcher-mirror-china-enabled = China mirror enabled.
+launcher-beta-releases-enabled = Beta releases enabled.
+launcher-beta-releases-disabled = Beta releases disabled.
+launcher-download-caching-enabled = Download caching enabled.
+launcher-download-caching-disabled = Download caching disabled and cache cleared.

ftl/qt-repo

@@ -1 +1 @@
-Subproject commit fd5f984785ad07a0d3dbd893ee3d7e3671eaebd6
+Subproject commit 0b7c530233390d73b706f012bbe7489539925c7d

proto/anki/collection.proto

@@ -20,6 +20,7 @@ service CollectionService {
   rpc LatestProgress(generic.Empty) returns (Progress);
   rpc SetWantsAbort(generic.Empty) returns (generic.Empty);
   rpc SetLoadBalancerEnabled(generic.Bool) returns (OpChanges);
+  rpc GetCustomColours(generic.Empty) returns (GetCustomColoursResponse);
 }
 
 // Implicitly includes any of the above methods that are not listed in the
@@ -163,3 +164,7 @@ message CreateBackupRequest {
   bool force = 2;
   bool wait_for_completion = 3;
 }
+
+message GetCustomColoursResponse {
+  repeated string colours = 1;
+}

proto/anki/stats.proto

@@ -37,6 +37,8 @@ message CardStatsResponse {
     uint32 ease = 5;
     float taken_secs = 6;
     optional cards.FsrsMemoryState memory_state = 7;
+    // seconds
+    uint32 last_interval = 8;
   }
   repeated StatsRevlogEntry revlog = 1;
   int64 card_id = 2;

pylib/tests/test_find.py

@@ -32,6 +32,7 @@ def test_find_cards():
     note = col.newNote()
     note["Front"] = "cat"
     note["Back"] = "sheep"
+    note.tags.append("conjunção größte")
     col.addNote(note)
     catCard = note.cards()[0]
     m = col.models.current()
@@ -68,6 +69,8 @@ def test_find_cards():
     col.tags.bulk_remove(col.db.list("select id from notes"), "foo")
     assert len(col.find_cards("tag:foo")) == 0
     assert len(col.find_cards("tag:bar")) == 5
+    assert len(col.find_cards("tag:conjuncao tag:groste")) == 0
+    assert len(col.find_cards("tag:nc:conjuncao tag:nc:groste")) == 1
     # text searches
     assert len(col.find_cards("cat")) == 2
     assert len(col.find_cards("cat -dog")) == 1

qt/aqt/browser/browser.py

@@ -521,7 +521,7 @@ class Browser(QMainWindow):
         self.search()
 
     def current_search(self) -> str:
-        return self._line_edit().text()
+        return self._line_edit().text().replace("\n", " ")
 
     def search(self) -> None:
         """Search triggered programmatically. Caller must have saved note first."""

qt/aqt/mediasrv.py

@@ -630,7 +630,7 @@ def deck_options_ready() -> bytes:
 
 def save_custom_colours() -> bytes:
     colors = [
-        QColorDialog.customColor(i).name(QColor.NameFormat.HexArgb)
+        QColorDialog.customColor(i).name(QColor.NameFormat.HexRgb)
         for i in range(QColorDialog.customCount())
     ]
     aqt.mw.col.set_config("customColorPickerPalette", colors)
@@ -659,6 +659,7 @@ post_handler_list = [
 exposed_backend_list = [
     # CollectionService
     "latest_progress",
+    "get_custom_colours",
     # DeckService
     "get_deck_names",
     # I18nService

qt/launcher/Cargo.toml

@@ -8,11 +8,13 @@ publish = false
 rust-version.workspace = true
 
 [dependencies]
+anki_i18n.workspace = true
 anki_io.workspace = true
 anki_process.workspace = true
 anyhow.workspace = true
 camino.workspace = true
 dirs.workspace = true
+locale_config.workspace = true
 serde_json.workspace = true
 
 [target.'cfg(all(unix, not(target_os = "macos")))'.dependencies]

qt/launcher/src/main.rs

@@ -10,6 +10,7 @@ use std::process::Command;
 use std::time::SystemTime;
 use std::time::UNIX_EPOCH;
 
+use anki_i18n::I18n;
 use anki_io::copy_file;
 use anki_io::create_dir_all;
 use anki_io::modified_time;
@@ -31,6 +32,7 @@ use crate::platform::respawn_launcher;
 mod platform;
 
 struct State {
+    tr: I18n<anki_i18n::Launcher>,
     current_version: Option<String>,
     prerelease_marker: std::path::PathBuf,
     uv_install_root: std::path::PathBuf,
@@ -100,7 +102,14 @@ fn run() -> Result<()> {
 
     let (exe_dir, resources_dir) = get_exe_and_resources_dirs()?;
 
+    let locale = locale_config::Locale::user_default().to_string();
+
     let mut state = State {
+        tr: I18n::new(&[if !locale.is_empty() {
+            locale
+        } else {
+            "en".to_owned()
+        }]),
         current_version: None,
         prerelease_marker: uv_install_root.join("prerelease"),
         uv_install_root: uv_install_root.clone(),
@@ -160,8 +169,7 @@ fn run() -> Result<()> {
     }
 
     print!("\x1B[2J\x1B[H"); // Clear screen and move cursor to top
-    println!("\x1B[1mAnki Launcher\x1B[0m\n");
+    println!("\x1B[1m{}\x1B[0m\n", state.tr.launcher_title());
-    println!("This is the Anki Launcher. If you're running it for the first time, press Enter to install the latest version. Otherwise, pressing Enter will check for updates and then open Anki.\n");
 
     ensure_os_supported()?;
 
@@ -179,15 +187,18 @@ fn run() -> Result<()> {
     }
 
     if cfg!(unix) && !cfg!(target_os = "macos") {
-        println!("\nPress enter to start Anki.");
+        println!("\n{}", state.tr.launcher_press_enter_to_start());
         let mut input = String::new();
         let _ = stdin().read_line(&mut input);
     } else {
         // on Windows/macOS, the user needs to close the terminal/console
         // currently, but ideas on how we can avoid this would be good!
         println!();
-        println!("Anki will start shortly.");
+        println!("{}", state.tr.launcher_anki_will_start_shortly());
-        println!("\x1B[1mYou can close this window.\x1B[0m\n");
+        println!(
+            "\x1B[1m{}\x1B[0m\n",
+            state.tr.launcher_you_can_close_this_window()
+        );
     }
 
     // respawn the launcher as a disconnected subprocess for normal startup
@@ -259,7 +270,7 @@ fn handle_version_install_or_update(state: &State, choice: MainMenuChoice) -> Re
     // Remove sync marker before attempting sync
     let _ = remove_file(&state.sync_complete_marker);
 
-    println!("Updating Anki...\n");
+    println!("{}\n", state.tr.launcher_updating_anki());
 
     let python_version_trimmed = if state.user_python_version_path.exists() {
         let python_version = read_file(&state.user_python_version_path)?;
@@ -379,10 +390,10 @@ fn main_menu_loop(state: &State) -> Result<()> {
                 // Toggle beta prerelease file
                 if state.prerelease_marker.exists() {
                     let _ = remove_file(&state.prerelease_marker);
-                    println!("Beta releases disabled.");
+                    println!("{}", state.tr.launcher_beta_releases_disabled());
                 } else {
                     write_file(&state.prerelease_marker, "")?;
-                    println!("Beta releases enabled.");
+                    println!("{}", state.tr.launcher_beta_releases_enabled());
                 }
                 println!();
                 continue;
@@ -391,14 +402,14 @@ fn main_menu_loop(state: &State) -> Result<()> {
                 // Toggle cache disable file
                 if state.no_cache_marker.exists() {
                     let _ = remove_file(&state.no_cache_marker);
-                    println!("Download caching enabled.");
+                    println!("{}", state.tr.launcher_download_caching_enabled());
                 } else {
                     write_file(&state.no_cache_marker, "")?;
                     // Delete the cache directory and everything in it
                     if state.uv_cache_dir.exists() {
                         let _ = anki_io::remove_dir_all(&state.uv_cache_dir);
                     }
-                    println!("Download caching disabled and cache cleared.");
+                    println!("{}", state.tr.launcher_download_caching_disabled());
                 }
                 println!();
                 continue;
@@ -441,44 +452,62 @@ fn file_timestamp_secs(path: &std::path::Path) -> i64 {
 
 fn get_main_menu_choice(state: &State) -> Result<MainMenuChoice> {
     loop {
-        println!("1) Install Latest Anki (press Enter)");
+        println!("1) {}", state.tr.launcher_latest_anki());
-        println!("2) Choose a specific version");
+        println!("2) {}", state.tr.launcher_choose_a_version());
 
         if let Some(current_version) = &state.current_version {
             let normalized_current = normalize_version(current_version);
 
             if state.pyproject_modified_by_user {
-                println!("3) Sync project changes");
+                println!("3) {}", state.tr.launcher_sync_project_changes());
             } else {
-                println!("3) Keep existing version ({normalized_current})");
+                println!(
+                    "3) {}",
+                    state.tr.launcher_keep_existing_version(normalized_current)
+                );
             }
         }
 
         if let Some(prev_version) = &state.previous_version {
             if state.current_version.as_ref() != Some(prev_version) {
                 let normalized_prev = normalize_version(prev_version);
-                println!("4) Revert to previous version ({normalized_prev})");
+                println!(
+                    "4) {}",
+                    state.tr.launcher_revert_to_previous(normalized_prev)
+                );
             }
         }
         println!();
 
         let betas_enabled = state.prerelease_marker.exists();
         println!(
-            "5) Allow betas: {}",
+            "5) {}",
-            if betas_enabled { "on" } else { "off" }
+            state.tr.launcher_allow_betas(if betas_enabled {
+                state.tr.launcher_on()
+            } else {
+                state.tr.launcher_off()
+            })
         );
         let cache_enabled = !state.no_cache_marker.exists();
         println!(
-            "6) Cache downloads: {}",
+            "6) {}",
-            if cache_enabled { "on" } else { "off" }
+            state.tr.launcher_cache_downloads(if cache_enabled {
+                state.tr.launcher_on()
+            } else {
+                state.tr.launcher_off()
+            })
         );
         let mirror_enabled = is_mirror_enabled(state);
         println!(
-            "7) Download mirror: {}",
+            "7) {}",
-            if mirror_enabled { "on" } else { "off" }
+            state.tr.launcher_download_mirror(if mirror_enabled {
+                state.tr.launcher_on()
+            } else {
+                state.tr.launcher_off()
+            })
         );
         println!();
-        println!("8) Uninstall Anki");
+        println!("8) {}", state.tr.launcher_uninstall());
         print!("> ");
         let _ = stdout().flush();
 
@@ -500,7 +529,7 @@ fn get_main_menu_choice(state: &State) -> Result<MainMenuChoice> {
                 if state.current_version.is_some() {
                     MainMenuChoice::KeepExisting
                 } else {
-                    println!("Invalid input. Please try again.\n");
+                    println!("{}\n", state.tr.launcher_invalid_input());
                     continue;
                 }
             }
@@ -512,7 +541,7 @@ fn get_main_menu_choice(state: &State) -> Result<MainMenuChoice> {
                         }
                     }
                 }
-                println!("Invalid input. Please try again.\n");
+                println!("{}\n", state.tr.launcher_invalid_input());
                 continue;
             }
             "5" => MainMenuChoice::ToggleBetas,
@@ -520,7 +549,7 @@ fn get_main_menu_choice(state: &State) -> Result<MainMenuChoice> {
             "7" => MainMenuChoice::DownloadMirror,
             "8" => MainMenuChoice::Uninstall,
             _ => {
-                println!("Invalid input. Please try again.");
+                println!("{}\n", state.tr.launcher_invalid_input());
                 continue;
             }
         });
@@ -535,9 +564,9 @@ fn get_version_kind(state: &State) -> Result<Option<VersionKind>> {
         .map(|v| v.as_str())
         .collect::<Vec<_>>()
         .join(", ");
-    println!("Latest releases: {releases_str}");
+    println!("{}", state.tr.launcher_latest_releases(releases_str));
 
-    println!("Enter the version you want to install:");
+    println!("{}", state.tr.launcher_enter_the_version_you_want());
     print!("> ");
     let _ = stdout().flush();
 
@@ -561,11 +590,11 @@ fn get_version_kind(state: &State) -> Result<Option<VersionKind>> {
             Ok(Some(version_kind))
         }
         (None, true) => {
-            println!("Versions before 2.1.50 can't be installed.");
+            println!("{}", state.tr.launcher_versions_before_cant_be_installed());
             Ok(None)
         }
         _ => {
-            println!("Invalid version.\n");
+            println!("{}\n", state.tr.launcher_invalid_version());
             Ok(None)
         }
     }
@@ -701,7 +730,7 @@ fn fetch_versions(state: &State) -> Result<Vec<String>> {
     let output = match cmd.utf8_output() {
         Ok(output) => output,
         Err(e) => {
-            print!("Unable to check for Anki versions. Please check your internet connection.\n\n");
+            print!("{}\n\n", state.tr.launcher_unable_to_check_for_versions());
             return Err(e.into());
         }
     };
@@ -710,7 +739,7 @@ fn fetch_versions(state: &State) -> Result<Vec<String>> {
 }
 
 fn get_releases(state: &State) -> Result<Releases> {
-    println!("Checking for updates...");
+    println!("{}", state.tr.launcher_checking_for_updates());
     let include_prereleases = state.prerelease_marker.exists();
     let all_versions = fetch_versions(state)?;
     let all_versions = filter_and_normalize_versions(all_versions, include_prereleases);
@@ -912,7 +941,7 @@ fn get_anki_addons21_path() -> Result<std::path::PathBuf> {
 }
 
 fn handle_uninstall(state: &State) -> Result<bool> {
-    println!("Uninstall Anki's program files? (y/n)");
+    println!("{}", state.tr.launcher_uninstall_confirm());
     print!("> ");
     let _ = stdout().flush();
 
@@ -921,7 +950,7 @@ fn handle_uninstall(state: &State) -> Result<bool> {
     let input = input.trim().to_lowercase();
 
     if input != "y" {
-        println!("Uninstall cancelled.");
+        println!("{}", state.tr.launcher_uninstall_cancelled());
         println!();
         return Ok(false);
     }
@@ -929,11 +958,11 @@ fn handle_uninstall(state: &State) -> Result<bool> {
     // Remove program files
     if state.uv_install_root.exists() {
         anki_io::remove_dir_all(&state.uv_install_root)?;
-        println!("Program files removed.");
+        println!("{}", state.tr.launcher_program_files_removed());
     }
 
     println!();
-    println!("Remove all profiles/cards? (y/n)");
+    println!("{}", state.tr.launcher_remove_all_profiles_confirm());
     print!("> ");
     let _ = stdout().flush();
 
@@ -943,7 +972,7 @@ fn handle_uninstall(state: &State) -> Result<bool> {
 
     if input == "y" && state.anki_base_folder.exists() {
         anki_io::remove_dir_all(&state.anki_base_folder)?;
-        println!("User data removed.");
+        println!("{}", state.tr.launcher_user_data_removed());
     }
 
     println!();
@@ -1037,9 +1066,9 @@ fn get_mirror_urls(state: &State) -> Result<Option<(String, String)>> {
 
 fn show_mirror_submenu(state: &State) -> Result<()> {
     loop {
-        println!("Download mirror options:");
+        println!("{}", state.tr.launcher_download_mirror_options());
-        println!("1) No mirror");
+        println!("1) {}", state.tr.launcher_mirror_no_mirror());
-        println!("2) China");
+        println!("2) {}", state.tr.launcher_mirror_china());
         print!("> ");
         let _ = stdout().flush();
 
@@ -1053,14 +1082,14 @@ fn show_mirror_submenu(state: &State) -> Result<()> {
                 if state.mirror_path.exists() {
                     let _ = remove_file(&state.mirror_path);
                 }
-                println!("Mirror disabled.");
+                println!("{}", state.tr.launcher_mirror_disabled());
                 break;
             }
             "2" => {
                 // Write China mirror URLs
                 let china_mirrors = "https://registry.npmmirror.com/-/binary/python-build-standalone/\nhttps://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple/";
                 write_file(&state.mirror_path, china_mirrors)?;
-                println!("China mirror enabled.");
+                println!("{}", state.tr.launcher_mirror_china_enabled());
                 break;
             }
             "" => {
@@ -1068,7 +1097,7 @@ fn show_mirror_submenu(state: &State) -> Result<()> {
                 break;
             }
             _ => {
-                println!("Invalid input. Please try again.");
+                println!("{}", state.tr.launcher_invalid_input());
                 continue;
             }
         }

rslib/i18n/build.rs

@@ -23,10 +23,10 @@ use write_strings::write_strings;
 
 fn main() -> Result<()> {
     // generate our own requirements
-    let map = get_ftl_data();
+    let mut map = get_ftl_data();
     check(&map);
-    let modules = get_modules(&map);
+    let mut modules = get_modules(&map);
-    write_strings(&map, &modules);
+    write_strings(&map, &modules, "strings.rs", "All");
 
     typescript::write_ts_interface(&modules)?;
     python::write_py_interface(&modules)?;
@@ -41,5 +41,12 @@ fn main() -> Result<()> {
             write_file_if_changed(path, meta_json)?;
         }
     }
+
+    // generate strings for the launcher
+    map.iter_mut()
+        .for_each(|(_, modules)| modules.retain(|module, _| module == "launcher"));
+    modules.retain(|module| module.name == "launcher");
+    write_strings(&map, &modules, "strings_launcher.rs", "Launcher");
+
     Ok(())
 }

rslib/i18n/src/generated.rs

@@ -1,8 +1,15 @@
 // Copyright: Ankitects Pty Ltd and contributors
 // License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
 
-// Include auto-generated content
-
 #![allow(clippy::all)]
 
+#[derive(Clone)]
+pub struct All;
+
+// Include auto-generated content
 include!(concat!(env!("OUT_DIR"), "/strings.rs"));
+
+impl Translations for All {
+    const STRINGS: &phf::Map<&str, &phf::Map<&str, &str>> = &_STRINGS;
+    const KEYS_BY_MODULE: &[&[&str]] = &_KEYS_BY_MODULE;
+}

rslib/i18n/src/generated_launcher.rs

@@ -0,0 +1,15 @@
+// Copyright: Ankitects Pty Ltd and contributors
+// License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
+
+#![allow(clippy::all)]
+
+#[derive(Clone)]
+pub struct Launcher;
+
+// Include auto-generated content
+include!(concat!(env!("OUT_DIR"), "/strings_launcher.rs"));
+
+impl Translations for Launcher {
+    const STRINGS: &phf::Map<&str, &phf::Map<&str, &str>> = &_STRINGS;
+    const KEYS_BY_MODULE: &[&[&str]] = &_KEYS_BY_MODULE;
+}

rslib/i18n/src/lib.rs

@@ -2,8 +2,10 @@
 // License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
 
 mod generated;
+mod generated_launcher;
 
 use std::borrow::Cow;
+use std::marker::PhantomData;
 use std::sync::Arc;
 use std::sync::Mutex;
 
@@ -12,8 +14,6 @@ use fluent::FluentArgs;
 use fluent::FluentResource;
 use fluent::FluentValue;
 use fluent_bundle::bundle::FluentBundle as FluentBundleOrig;
-use generated::KEYS_BY_MODULE;
-use generated::STRINGS;
 use num_format::Locale;
 use serde::Serialize;
 use unic_langid::LanguageIdentifier;
@@ -22,6 +22,9 @@ type FluentBundle<T> = FluentBundleOrig<T, intl_memoizer::concurrent::IntlLangMe
 
 pub use fluent::fluent_args as tr_args;
 
+pub use crate::generated::All;
+pub use crate::generated_launcher::Launcher;
+
 pub trait Number: Into<FluentNumber> {
     fn round(self) -> Self;
 }
@@ -187,20 +190,67 @@ fn get_bundle_with_extra(
     get_bundle(text, extra_text, &locales)
 }
 
-#[derive(Clone)]
+pub trait Translations {
-pub struct I18n {
+    const STRINGS: &phf::Map<&str, &phf::Map<&str, &str>>;
-    inner: Arc<Mutex<I18nInner>>,
+    const KEYS_BY_MODULE: &[&[&str]];
 }
 
+#[derive(Clone)]
+pub struct I18n<P: Translations = All> {
+    inner: Arc<Mutex<I18nInner>>,
+    _translations_type: std::marker::PhantomData<P>,
+}
+
+impl<P: Translations> I18n<P> {
     fn get_key(module_idx: usize, translation_idx: usize) -> &'static str {
-    KEYS_BY_MODULE
+        P::KEYS_BY_MODULE
             .get(module_idx)
             .and_then(|translations| translations.get(translation_idx))
             .cloned()
             .unwrap_or("invalid-module-or-translation-index")
     }
 
-impl I18n {
+    fn get_modules(langs: &[LanguageIdentifier], desired_modules: &[String]) -> Vec<String> {
+        langs
+            .iter()
+            .cloned()
+            .map(|lang| {
+                let mut buf = String::new();
+                let lang_name = remapped_lang_name(&lang);
+                if let Some(strings) = P::STRINGS.get(lang_name) {
+                    if desired_modules.is_empty() {
+                        // empty list, provide all modules
+                        for value in strings.values() {
+                            buf.push_str(value)
+                        }
+                    } else {
+                        for module_name in desired_modules {
+                            if let Some(text) = strings.get(module_name.as_str()) {
+                                buf.push_str(text);
+                            }
+                        }
+                    }
+                }
+                buf
+            })
+            .collect()
+    }
+
+    /// This temporarily behaves like the older code; in the future we could
+    /// either access each &str separately, or load them on demand.
+    fn ftl_localized_text(lang: &LanguageIdentifier) -> Option<String> {
+        let lang = remapped_lang_name(lang);
+        if let Some(module) = P::STRINGS.get(lang) {
+            let mut text = String::new();
+            for module_text in module.values() {
+                text.push_str(module_text)
+            }
+            Some(text)
+        } else {
+            None
+        }
+    }
+
     pub fn template_only() -> Self {
         Self::new::<&str>(&[])
     }
@@ -225,7 +275,7 @@ impl I18n {
         let mut output_langs = vec![];
         for lang in input_langs {
             // if the language is bundled in the binary
-            if let Some(text) = ftl_localized_text(&lang).or_else(|| {
+            if let Some(text) = Self::ftl_localized_text(&lang).or_else(|| {
                 // when testing, allow missing translations
                 if cfg!(test) {
                     Some(String::new())
@@ -244,7 +294,7 @@ impl I18n {
 
         // add English templates
         let template_lang = "en-US".parse().unwrap();
-        let template_text = ftl_localized_text(&template_lang).unwrap();
+        let template_text = Self::ftl_localized_text(&template_lang).unwrap();
         let template_bundle = get_bundle_with_extra(&template_text, None).unwrap();
         bundles.push(template_bundle);
         output_langs.push(template_lang);
@@ -261,6 +311,7 @@ impl I18n {
                 bundles,
                 langs: output_langs,
             })),
+            _translations_type: PhantomData,
         }
     }
 
@@ -270,7 +321,7 @@ impl I18n {
         message_index: usize,
         args: FluentArgs,
     ) -> String {
-        let key = get_key(module_index, message_index);
+        let key = Self::get_key(module_index, message_index);
         self.translate(key, Some(args)).into()
     }
 
@@ -305,7 +356,7 @@ impl I18n {
     /// implementation.
     pub fn resources_for_js(&self, desired_modules: &[String]) -> ResourcesForJavascript {
         let inner = self.inner.lock().unwrap();
-        let resources = get_modules(&inner.langs, desired_modules);
+        let resources = Self::get_modules(&inner.langs, desired_modules);
         ResourcesForJavascript {
             langs: inner.langs.iter().map(ToString::to_string).collect(),
             resources,
@@ -313,47 +364,6 @@ impl I18n {
     }
 }
 
-fn get_modules(langs: &[LanguageIdentifier], desired_modules: &[String]) -> Vec<String> {
-    langs
-        .iter()
-        .cloned()
-        .map(|lang| {
-            let mut buf = String::new();
-            let lang_name = remapped_lang_name(&lang);
-            if let Some(strings) = STRINGS.get(lang_name) {
-                if desired_modules.is_empty() {
-                    // empty list, provide all modules
-                    for value in strings.values() {
-                        buf.push_str(value)
-                    }
-                } else {
-                    for module_name in desired_modules {
-                        if let Some(text) = strings.get(module_name.as_str()) {
-                            buf.push_str(text);
-                        }
-                    }
-                }
-            }
-            buf
-        })
-        .collect()
-}
-
-/// This temporarily behaves like the older code; in the future we could either
-/// access each &str separately, or load them on demand.
-fn ftl_localized_text(lang: &LanguageIdentifier) -> Option<String> {
-    let lang = remapped_lang_name(lang);
-    if let Some(module) = STRINGS.get(lang) {
-        let mut text = String::new();
-        for module_text in module.values() {
-            text.push_str(module_text)
-        }
-        Some(text)
-    } else {
-        None
-    }
-}
-
 struct I18nInner {
     // bundles in preferred language order, with template English as the
     // last element
@@ -490,7 +500,7 @@ mod test {
     #[test]
     fn i18n() {
         // English template
-        let tr = I18n::new(&["zz"]);
+        let tr = I18n::<All>::new(&["zz"]);
         assert_eq!(tr.translate("valid-key", None), "a valid key");
         assert_eq!(tr.translate("invalid-key", None), "invalid-key");
 
@@ -513,7 +523,7 @@ mod test {
         );
 
         // Another language
-        let tr = I18n::new(&["ja_JP"]);
+        let tr = I18n::<All>::new(&["ja_JP"]);
         assert_eq!(tr.translate("valid-key", None), "キー");
         assert_eq!(tr.translate("only-in-english", None), "not translated");
         assert_eq!(tr.translate("invalid-key", None), "invalid-key");
@@ -524,7 +534,7 @@ mod test {
         );
 
         // Decimal separator
-        let tr = I18n::new(&["pl-PL"]);
+        let tr = I18n::<All>::new(&["pl-PL"]);
         // Polish will use a comma if the string is translated
         assert_eq!(
             tr.translate("one-arg-key", Some(tr_args!["one"=>2.07])),

rslib/i18n/write_strings.rs

@@ -15,7 +15,7 @@ use crate::extract::VariableKind;
 use crate::gather::TranslationsByFile;
 use crate::gather::TranslationsByLang;
 
-pub fn write_strings(map: &TranslationsByLang, modules: &[Module]) {
+pub fn write_strings(map: &TranslationsByLang, modules: &[Module], out_fn: &str, tag: &str) {
     let mut buf = String::new();
 
     // lang->module map
@@ -25,23 +25,25 @@ pub fn write_strings(map: &TranslationsByLang, modules: &[Module]) {
     // ordered list of translations by module
     write_translation_key_index(modules, &mut buf);
     // methods to generate messages
-    write_methods(modules, &mut buf);
+    write_methods(modules, &mut buf, tag);
 
     let dir = PathBuf::from(std::env::var("OUT_DIR").unwrap());
-    let path = dir.join("strings.rs");
+    let path = dir.join(out_fn);
     fs::write(path, buf).unwrap();
 }
 
-fn write_methods(modules: &[Module], buf: &mut String) {
+fn write_methods(modules: &[Module], buf: &mut String, tag: &str) {
     buf.push_str(
         r#"
-use crate::{I18n,Number};
+#[allow(unused_imports)]
+use crate::{I18n,Number,Translations};
+#[allow(unused_imports)]
 use fluent::{FluentValue, FluentArgs};
 use std::borrow::Cow;
 
-impl I18n {
 "#,
     );
+    writeln!(buf, "impl I18n<{tag}> {{").unwrap();
     for module in modules {
         for translation in &module.translations {
             let func = translation.key.to_snake_case();
@@ -142,7 +144,7 @@ fn write_translation_key_index(modules: &[Module], buf: &mut String) {
 
     writeln!(
         buf,
-        "pub(crate) const KEYS_BY_MODULE: [&[&str]; {count}] = [",
+        "pub(crate) const _KEYS_BY_MODULE: [&[&str]; {count}] = [",
         count = modules.len(),
     )
     .unwrap();
@@ -162,7 +164,7 @@ fn write_translation_key_index(modules: &[Module], buf: &mut String) {
 fn write_lang_map(map: &TranslationsByLang, buf: &mut String) {
     buf.push_str(
         "
-pub(crate) const STRINGS: phf::Map<&str, &phf::Map<&str, &str>> = phf::phf_map! {
+pub(crate) const _STRINGS: phf::Map<&str, &phf::Map<&str, &str>> = phf::phf_map! {
 ",
     );
 

rslib/src/cloze.rs

@@ -10,6 +10,7 @@ use std::sync::LazyLock;
 use anki_proto::image_occlusion::get_image_occlusion_note_response::ImageOcclusion;
 use anki_proto::image_occlusion::get_image_occlusion_note_response::ImageOcclusionShape;
 use htmlescape::encode_attribute;
+use itertools::Itertools;
 use nom::branch::alt;
 use nom::bytes::complete::tag;
 use nom::bytes::complete::take_while;
@@ -26,7 +27,7 @@ use crate::template::RenderContext;
 use crate::text::strip_html_preserving_entities;
 
 static CLOZE: LazyLock<Regex> =
-    LazyLock::new(|| Regex::new(r"(?s)\{\{c\d+::(.*?)(::.*?)?\}\}").unwrap());
+    LazyLock::new(|| Regex::new(r"(?s)\{\{c[\d,]+::(.*?)(::.*?)?\}\}").unwrap());
 
 static MATHJAX: LazyLock<Regex> = LazyLock::new(|| {
     Regex::new(
@@ -48,7 +49,7 @@ mod mathjax_caps {
 #[derive(Debug)]
 enum Token<'a> {
     // The parameter is the cloze number as is appears in the field content.
-    OpenCloze(u16),
+    OpenCloze(Vec<u16>),
     Text(&'a str),
     CloseCloze,
 }
@@ -58,21 +59,24 @@ fn tokenize(mut text: &str) -> impl Iterator<Item = Token<'_>> {
     fn open_cloze(text: &str) -> IResult<&str, Token<'_>> {
         // opening brackets and 'c'
         let (text, _opening_brackets_and_c) = tag("{{c")(text)?;
-        // following number
+        // following comma-seperated numbers
-        let (text, digits) = take_while(|c: char| c.is_ascii_digit())(text)?;
+        let (text, ordinals) = take_while(|c: char| c.is_ascii_digit() || c == ',')(text)?;
-        let digits: u16 = match digits.parse() {
+        let ordinals: Vec<u16> = ordinals
-            Ok(digits) => digits,
+            .split(',')
-            Err(_) => {
+            .filter_map(|s| s.parse().ok())
-                // not a valid number; fail to recognize
+            .collect::<HashSet<_>>() // deduplicate
+            .into_iter()
+            .sorted() // set conversion can de-order
+            .collect();
+        if ordinals.is_empty() {
             return Err(nom::Err::Error(nom::error::make_error(
                 text,
                 nom::error::ErrorKind::Digit,
             )));
         }
-        };
         // ::
         let (text, _colons) = tag("::")(text)?;
-        Ok((text, Token::OpenCloze(digits)))
+        Ok((text, Token::OpenCloze(ordinals)))
     }
 
     fn close_cloze(text: &str) -> IResult<&str, Token<'_>> {
@@ -121,11 +125,20 @@ enum TextOrCloze<'a> {
 #[derive(Debug)]
 struct ExtractedCloze<'a> {
     // `ordinal` is the cloze number as is appears in the field content.
-    ordinal: u16,
+    ordinals: Vec<u16>,
     nodes: Vec<TextOrCloze<'a>>,
     hint: Option<&'a str>,
 }
 
+/// Generate a string representation of the ordinals for HTML
+fn ordinals_str(ordinals: &[u16]) -> String {
+    ordinals
+        .iter()
+        .map(|o| o.to_string())
+        .collect::<Vec<_>>()
+        .join(",")
+}
+
 impl ExtractedCloze<'_> {
     /// Return the cloze's hint, or "..." if none was provided.
     fn hint(&self) -> &str {
@@ -151,6 +164,11 @@ impl ExtractedCloze<'_> {
         buf.into()
     }
 
+    /// Checks if this cloze is active for a given ordinal
+    fn contains_ordinal(&self, ordinal: u16) -> bool {
+        self.ordinals.contains(&ordinal)
+    }
+
     /// If cloze starts with image-occlusion:, return the text following that.
     fn image_occlusion(&self) -> Option<&str> {
         let TextOrCloze::Text(text) = self.nodes.first()? else {
@@ -165,10 +183,10 @@ fn parse_text_with_clozes(text: &str) -> Vec<TextOrCloze<'_>> {
     let mut output = vec![];
     for token in tokenize(text) {
         match token {
-            Token::OpenCloze(ordinal) => {
+            Token::OpenCloze(ordinals) => {
                 if open_clozes.len() < 10 {
                     open_clozes.push(ExtractedCloze {
-                        ordinal,
+                        ordinals,
                         nodes: Vec::with_capacity(1), // common case
                         hint: None,
                     })
@@ -214,7 +232,7 @@ fn reveal_cloze_text_in_nodes(
     output: &mut Vec<String>,
 ) {
     if let TextOrCloze::Cloze(cloze) = node {
-        if cloze.ordinal == cloze_ord {
+        if cloze.contains_ordinal(cloze_ord) {
             if question {
                 output.push(cloze.hint().into())
             } else {
@@ -234,14 +252,16 @@ fn reveal_cloze(
     active_cloze_found_in_text: &mut bool,
     buf: &mut String,
 ) {
-    let active = cloze.ordinal == cloze_ord;
+    let active = cloze.contains_ordinal(cloze_ord);
     *active_cloze_found_in_text |= active;
+
     if let Some(image_occlusion_text) = cloze.image_occlusion() {
         buf.push_str(&render_image_occlusion(
             image_occlusion_text,
             question,
             active,
-            cloze.ordinal,
+            cloze_ord,
+            &cloze.ordinals,
         ));
         return;
     }
@@ -265,7 +285,7 @@ fn reveal_cloze(
                 buf,
                 r#"<span class="cloze" data-cloze="{}" data-ordinal="{}">[{}]</span>"#,
                 encode_attribute(&content_buf),
-                cloze.ordinal,
+                ordinals_str(&cloze.ordinals),
                 cloze.hint()
             )
             .unwrap();
@@ -274,7 +294,7 @@ fn reveal_cloze(
             write!(
                 buf,
                 r#"<span class="cloze" data-ordinal="{}">"#,
-                cloze.ordinal
+                ordinals_str(&cloze.ordinals)
             )
             .unwrap();
             for node in &cloze.nodes {
@@ -292,7 +312,7 @@ fn reveal_cloze(
             write!(
                 buf,
                 r#"<span class="cloze-inactive" data-ordinal="{}">"#,
-                cloze.ordinal
+                ordinals_str(&cloze.ordinals)
             )
             .unwrap();
             for node in &cloze.nodes {
@@ -308,23 +328,29 @@ fn reveal_cloze(
     }
 }
 
-fn render_image_occlusion(text: &str, question_side: bool, active: bool, ordinal: u16) -> String {
+fn render_image_occlusion(
+    text: &str,
+    question_side: bool,
+    active: bool,
+    ordinal: u16,
+    ordinals: &[u16],
+) -> String {
     if (question_side && active) || ordinal == 0 {
         format!(
             r#"<div class="cloze" data-ordinal="{}" {}></div>"#,
-            ordinal,
+            ordinals_str(ordinals),
             &get_image_cloze_data(text)
         )
     } else if !active {
         format!(
             r#"<div class="cloze-inactive" data-ordinal="{}" {}></div>"#,
-            ordinal,
+            ordinals_str(ordinals),
             &get_image_cloze_data(text)
         )
     } else if !question_side && active {
         format!(
             r#"<div class="cloze-highlight" data-ordinal="{}" {}></div>"#,
-            ordinal,
+            ordinals_str(ordinals),
             &get_image_cloze_data(text)
         )
     } else {
@@ -338,7 +364,10 @@ pub fn parse_image_occlusions(text: &str) -> Vec<ImageOcclusion> {
         if let TextOrCloze::Cloze(cloze) = node {
             if cloze.image_occlusion().is_some() {
                 if let Some(shape) = parse_image_cloze(cloze.image_occlusion().unwrap()) {
-                    occlusions.entry(cloze.ordinal).or_default().push(shape);
+                    // Associate this occlusion with all ordinals in this cloze
+                    for &ordinal in &cloze.ordinals {
+                        occlusions.entry(ordinal).or_default().push(shape.clone());
+                    }
                 }
             }
         }
@@ -420,7 +449,7 @@ pub fn expand_clozes_to_reveal_latex(text: &str) -> String {
 pub(crate) fn contains_cloze(text: &str) -> bool {
     parse_text_with_clozes(text)
         .iter()
-        .any(|node| matches!(node, TextOrCloze::Cloze(e) if e.ordinal != 0))
+        .any(|node| matches!(node, TextOrCloze::Cloze(e) if e.ordinals.iter().any(|&o| o != 0)))
 }
 
 /// Returns the set of cloze number as they appear in the fields's content.
@@ -433,11 +462,13 @@ pub fn cloze_numbers_in_string(html: &str) -> HashSet<u16> {
 fn add_cloze_numbers_in_text_with_clozes(nodes: &[TextOrCloze], set: &mut HashSet<u16>) {
     for node in nodes {
         if let TextOrCloze::Cloze(cloze) = node {
-            if cloze.ordinal != 0 {
+            for &ordinal in &cloze.ordinals {
-                set.insert(cloze.ordinal);
+                if ordinal != 0 {
-                add_cloze_numbers_in_text_with_clozes(&cloze.nodes, set);
+                    set.insert(ordinal);
                 }
             }
+            add_cloze_numbers_in_text_with_clozes(&cloze.nodes, set);
+        }
     }
 }
 
@@ -654,4 +685,160 @@ mod test {
             )
         );
     }
+
+    #[test]
+    fn multi_card_card_generation() {
+        let text = "{{c1,2,3::multi}}";
+        assert_eq!(
+            cloze_number_in_fields(vec![text]),
+            vec![1, 2, 3].into_iter().collect::<HashSet<u16>>()
+        );
+    }
+
+    #[test]
+    fn multi_card_cloze_basic() {
+        let text = "{{c1,2::shared}} word and {{c1::first}} vs {{c2::second}}";
+
+        assert_eq!(
+            strip_html(&reveal_cloze_text(text, 1, true)).as_ref(),
+            "[...] word and [...] vs second"
+        );
+        assert_eq!(
+            strip_html(&reveal_cloze_text(text, 2, true)).as_ref(),
+            "[...] word and first vs [...]"
+        );
+        assert_eq!(
+            strip_html(&reveal_cloze_text(text, 1, false)).as_ref(),
+            "shared word and first vs second"
+        );
+        assert_eq!(
+            strip_html(&reveal_cloze_text(text, 2, false)).as_ref(),
+            "shared word and first vs second"
+        );
+        assert_eq!(
+            cloze_numbers_in_string(text),
+            vec![1, 2].into_iter().collect::<HashSet<u16>>()
+        );
+    }
+
+    #[test]
+    fn multi_card_cloze_html_attributes() {
+        let text = "{{c1,2,3::multi}}";
+
+        let card1_html = reveal_cloze_text(text, 1, true);
+        assert!(card1_html.contains(r#"data-ordinal="1,2,3""#));
+
+        let card2_html = reveal_cloze_text(text, 2, true);
+        assert!(card2_html.contains(r#"data-ordinal="1,2,3""#));
+
+        let card3_html = reveal_cloze_text(text, 3, true);
+        assert!(card3_html.contains(r#"data-ordinal="1,2,3""#));
+    }
+
+    #[test]
+    fn multi_card_cloze_with_hints() {
+        let text = "{{c1,2::answer::hint}}";
+
+        assert_eq!(
+            strip_html(&reveal_cloze_text(text, 1, true)).as_ref(),
+            "[hint]"
+        );
+        assert_eq!(
+            strip_html(&reveal_cloze_text(text, 2, true)).as_ref(),
+            "[hint]"
+        );
+
+        assert_eq!(
+            strip_html(&reveal_cloze_text(text, 1, false)).as_ref(),
+            "answer"
+        );
+        assert_eq!(
+            strip_html(&reveal_cloze_text(text, 2, false)).as_ref(),
+            "answer"
+        );
+    }
+
+    #[test]
+    fn multi_card_cloze_edge_cases() {
+        assert_eq!(
+            cloze_numbers_in_string("{{c1,1,2::test}}"),
+            vec![1, 2].into_iter().collect::<HashSet<u16>>()
+        );
+
+        assert_eq!(
+            cloze_numbers_in_string("{{c0,1,2::test}}"),
+            vec![1, 2].into_iter().collect::<HashSet<u16>>()
+        );
+
+        assert_eq!(
+            cloze_numbers_in_string("{{c1,,3::test}}"),
+            vec![1, 3].into_iter().collect::<HashSet<u16>>()
+        );
+    }
+
+    #[test]
+    fn multi_card_cloze_only_filter() {
+        let text = "{{c1,2::shared}} and {{c1::first}} vs {{c2::second}}";
+
+        assert_eq!(reveal_cloze_text_only(text, 1, true), "..., ...");
+        assert_eq!(reveal_cloze_text_only(text, 2, true), "..., ...");
+        assert_eq!(reveal_cloze_text_only(text, 1, false), "shared, first");
+        assert_eq!(reveal_cloze_text_only(text, 2, false), "shared, second");
+    }
+
+    #[test]
+    fn multi_card_nested_cloze() {
+        let text = "{{c1,2::outer {{c3::inner}}}}";
+
+        assert_eq!(
+            strip_html(&reveal_cloze_text(text, 1, true)).as_ref(),
+            "[...]"
+        );
+
+        assert_eq!(
+            strip_html(&reveal_cloze_text(text, 2, true)).as_ref(),
+            "[...]"
+        );
+
+        assert_eq!(
+            strip_html(&reveal_cloze_text(text, 3, true)).as_ref(),
+            "outer [...]"
+        );
+
+        assert_eq!(
+            cloze_numbers_in_string(text),
+            vec![1, 2, 3].into_iter().collect::<HashSet<u16>>()
+        );
+    }
+
+    #[test]
+    fn nested_parent_child_card_same_cloze() {
+        let text = "{{c1::outer {{c1::inner}}}}";
+
+        assert_eq!(
+            strip_html(&reveal_cloze_text(text, 1, true)).as_ref(),
+            "[...]"
+        );
+
+        assert_eq!(
+            cloze_numbers_in_string(text),
+            vec![1].into_iter().collect::<HashSet<u16>>()
+        );
+    }
+
+    #[test]
+    fn multi_card_image_occlusion() {
+        let text = "{{c1,2::image-occlusion:rect:left=10:top=20:width=30:height=40}}";
+
+        let occlusions = parse_image_occlusions(text);
+        assert_eq!(occlusions.len(), 2);
+        assert!(occlusions.iter().any(|o| o.ordinal == 1));
+        assert!(occlusions.iter().any(|o| o.ordinal == 2));
+
+        let card1_html = reveal_cloze_text(text, 1, true);
+        assert!(card1_html.contains(r#"data-ordinal="1,2""#));
+
+        let card2_html = reveal_cloze_text(text, 2, true);
+        assert!(card2_html.contains(r#"data-ordinal="1,2""#));
+    }
 }

rslib/src/collection/service.rs

@@ -1,8 +1,10 @@
 // Copyright: Ankitects Pty Ltd and contributors
 // License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
+use anki_proto::collection::GetCustomColoursResponse;
 use anki_proto::generic;
 
 use crate::collection::Collection;
+use crate::config::ConfigKey;
 use crate::error;
 use crate::prelude::BoolKey;
 use crate::prelude::Op;
@@ -62,4 +64,13 @@ impl crate::services::CollectionService for Collection {
         })
         .map(Into::into)
     }
+
+    fn get_custom_colours(
+        &mut self,
+    ) -> error::Result<anki_proto::collection::GetCustomColoursResponse> {
+        let colours = self
+            .get_config_optional(ConfigKey::CustomColorPickerPalette)
+            .unwrap_or_default();
+        Ok(GetCustomColoursResponse { colours })
+    }
 }

rslib/src/config/mod.rs

@@ -71,6 +71,7 @@ pub(crate) enum ConfigKey {
     NextNewCardPosition,
     #[strum(to_string = "schedVer")]
     SchedulerVersion,
+    CustomColorPickerPalette,
 }
 
 #[derive(PartialEq, Eq, Serialize_repr, Deserialize_repr, Clone, Copy, Debug)]

rslib/src/revlog/mod.rs

@@ -85,6 +85,15 @@ impl RevlogEntry {
         .unwrap()
     }
 
+    pub(crate) fn last_interval_secs(&self) -> u32 {
+        u32::try_from(if self.last_interval > 0 {
+            self.last_interval.saturating_mul(86_400)
+        } else {
+            self.last_interval.saturating_mul(-1)
+        })
+        .unwrap()
+    }
+
     /// Returns true if this entry represents a reset operation.
     /// These entries are created when a card is reset using
     /// [`Collection::reschedule_cards_as_new`].

rslib/src/scheduler/fsrs/memory_state.rs

@@ -136,6 +136,19 @@ impl Collection {
                                             let deckconfig_id = deck.config_id().unwrap();
                                             // reschedule it
                                             let original_interval = card.interval;
+                                            let min_interval = |interval: u32| {
+                                                let previous_interval =
+                                                    last_info.previous_interval.unwrap_or(0);
+                                                if interval > previous_interval {
+                                                    // interval grew; don't allow fuzzed interval to
+                                                    // be less than previous+1
+                                                    previous_interval + 1
+                                                } else {
+                                                    // interval shrunk; don't restrict negative fuzz
+                                                    0
+                                                }
+                                                .max(1)
+                                            };
                                             let interval = fsrs.next_interval(
                                                 Some(state.stability),
                                                 desired_retention,
@@ -146,7 +159,7 @@ impl Collection {
                                                 .and_then(|r| {
                                                     r.find_interval(
                                                         interval,
-                                                        1,
+                                                        min_interval(interval as u32),
                                                         req.max_interval,
                                                         days_elapsed as u32,
                                                         deckconfig_id,
@@ -157,7 +170,7 @@ impl Collection {
                                                     with_review_fuzz(
                                                         card.get_fuzz_factor(true),
                                                         interval,
-                                                        1,
+                                                        min_interval(interval as u32),
                                                         req.max_interval,
                                                     )
                                                 });
@@ -310,6 +323,9 @@ pub(crate) struct LastRevlogInfo {
     /// reviewed the card and now, so that we can determine an accurate period
     /// when the card has subsequently been rescheduled to a different day.
     pub(crate) last_reviewed_at: Option<TimestampSecs>,
+    /// The interval before the latest review. Used to prevent fuzz from going
+    /// backwards when rescheduling the card
+    pub(crate) previous_interval: Option<u32>,
 }
 
 /// Return a map of cards to info about last review.
@@ -321,14 +337,27 @@ pub(crate) fn get_last_revlog_info(revlogs: &[RevlogEntry]) -> HashMap<CardId, L
         .into_iter()
         .for_each(|(card_id, group)| {
             let mut last_reviewed_at = None;
+            let mut previous_interval = None;
             for e in group.into_iter() {
                 if e.has_rating_and_affects_scheduling() {
                     last_reviewed_at = Some(e.id.as_secs());
+                    previous_interval = if e.last_interval >= 0 && e.button_chosen > 1 {
+                        Some(e.last_interval as u32)
+                    } else {
+                        None
+                    };
                 } else if e.is_reset() {
                     last_reviewed_at = None;
+                    previous_interval = None;
                 }
             }
-            out.insert(card_id, LastRevlogInfo { last_reviewed_at });
+            out.insert(
+                card_id,
+                LastRevlogInfo {
+                    last_reviewed_at,
+                    previous_interval,
+                },
+            );
         });
     out
 }

rslib/src/scheduler/fsrs/params.rs

@@ -478,27 +478,42 @@ pub(crate) fn reviews_for_fsrs(
         }))
         .collect_vec();
 
-    let skip = if training { 1 } else { 0 };
+    let items = if training {
         // Convert the remaining entries into separate FSRSItems, where each item
         // contains all reviews done until then.
-    let items: Vec<(RevlogId, FSRSItem)> = entries
+        let mut items = Vec::with_capacity(entries.len());
-        .iter()
+        let mut current_reviews = Vec::with_capacity(entries.len());
-        .enumerate()
+        for (idx, (entry, &delta_t)) in entries.iter().zip(delta_ts.iter()).enumerate() {
-        .skip(skip)
+            current_reviews.push(FSRSReview {
-        .map(|(outer_idx, entry)| {
+                rating: entry.button_chosen as u32,
+                delta_t,
+            });
+            if idx >= 1 && delta_t > 0 {
+                items.push((
+                    entry.id,
+                    FSRSItem {
+                        reviews: current_reviews.clone(),
+                    },
+                ));
+            }
+        }
+        items
+    } else {
+        // When not training, we only need the final FSRS item, which represents
+        // the complete history of the card. This avoids expensive clones in a loop.
         let reviews = entries
             .iter()
-                .take(outer_idx + 1)
+            .zip(delta_ts.iter())
-                .enumerate()
+            .map(|(entry, &delta_t)| FSRSReview {
-                .map(|(inner_idx, r)| FSRSReview {
+                rating: entry.button_chosen as u32,
-                    rating: r.button_chosen as u32,
+                delta_t,
-                    delta_t: delta_ts[inner_idx],
             })
             .collect();
-            (entry.id, FSRSItem { reviews })
+        let last_entry = entries.last().unwrap();
-        })
+
-        .filter(|(_, item)| !training || item.reviews.last().unwrap().delta_t > 0)
+        vec![(last_entry.id, FSRSItem { reviews })]
-        .collect_vec();
+    };
+
     if items.is_empty() {
         None
     } else {
@@ -738,7 +753,7 @@ pub(crate) mod tests {
                 ],
                 false,
             ),
-            fsrs_items!([review(0)], [review(0), review(1)])
+            fsrs_items!([review(0), review(1)])
         );
     }
 
@@ -809,7 +824,7 @@ pub(crate) mod tests {
         // R | A X R
         assert_eq!(
             convert_ignore_before(revlogs, false, days_ago_ms(9)),
-            fsrs_items!([review(0)], [review(0), review(2)])
+            fsrs_items!([review(0), review(2)])
         );
     }
 
@@ -828,6 +843,9 @@ pub(crate) mod tests {
         assert_eq!(
             convert_ignore_before(revlogs, false, days_ago_ms(9))
                 .unwrap()
+                .last()
+                .unwrap()
+                .reviews
                 .len(),
             2
         );
@@ -849,6 +867,9 @@ pub(crate) mod tests {
         assert_eq!(
             convert_ignore_before(revlogs, false, days_ago_ms(9))
                 .unwrap()
+                .last()
+                .unwrap()
+                .reviews
                 .len(),
             2
         );

rslib/src/scheduler/fsrs/rescheduler.rs

@@ -115,13 +115,14 @@ impl Rescheduler {
     pub fn find_interval(
         &self,
         interval: f32,
-        minimum: u32,
+        minimum_interval: u32,
-        maximum: u32,
+        maximum_interval: u32,
         days_elapsed: u32,
         deckconfig_id: DeckConfigId,
         fuzz_seed: Option<u64>,
     ) -> Option<u32> {
-        let (before_days, after_days) = constrained_fuzz_bounds(interval, minimum, maximum);
+        let (before_days, after_days) =
+            constrained_fuzz_bounds(interval, minimum_interval, maximum_interval);
 
         // Don't reschedule the card when it's overdue
         if after_days < days_elapsed {

rslib/src/search/parser.rs

@@ -392,6 +392,11 @@ fn parse_tag(s: &str) -> ParseResult<'_, SearchNode> {
             tag: unescape_quotes(re),
             mode: FieldSearchMode::Regex,
         }
+    } else if let Some(nc) = s.strip_prefix("nc:") {
+        SearchNode::Tag {
+            tag: unescape(nc)?,
+            mode: FieldSearchMode::NoCombining,
+        }
     } else {
         SearchNode::Tag {
             tag: unescape(s)?,

rslib/src/search/sqlwriter.rs

@@ -311,8 +311,19 @@ impl SqlWriter<'_> {
                 }
                 s if s.contains(' ') => write!(self.sql, "false").unwrap(),
                 text => {
+                    let text = if mode == FieldSearchMode::Normal {
                         write!(self.sql, "n.tags regexp ?").unwrap();
-                    let re = &to_custom_re(text, r"\S");
+                        Cow::from(text)
+                    } else {
+                        write!(
+                            self.sql,
+                            "coalesce(process_text(n.tags, {}), n.tags) regexp ?",
+                            ProcessTextFlags::NoCombining.bits()
+                        )
+                        .unwrap();
+                        without_combining(text)
+                    };
+                    let re = &to_custom_re(&text, r"\S");
                     self.args.push(format!("(?i).* {re}(::| ).*"));
                 }
             }

rslib/src/stats/card.rs

@@ -76,8 +76,15 @@ impl Collection {
             note_id: card.note_id.into(),
             deck: deck.human_name(),
             added: card.id.as_secs().0,
-            first_review: revlog.first().map(|entry| entry.id.as_secs().0),
+            first_review: revlog
-            latest_review: revlog.last().map(|entry| entry.id.as_secs().0),
+                .iter()
+                .find(|entry| entry.has_rating())
+                .map(|entry| entry.id.as_secs().0),
+            // last_review_time is not used to ensure cram revlogs are included.
+            latest_review: revlog
+                .iter()
+                .rfind(|entry| entry.has_rating())
+                .map(|entry| entry.id.as_secs().0),
             due_date: self.due_date(&card)?,
             due_position: self.position(&card),
             interval: card.interval,
@@ -220,6 +227,7 @@ fn stats_revlog_entry(
         ease: entry.ease_factor,
         taken_secs: entry.taken_millis as f32 / 1000.,
         memory_state: None,
+        last_interval: entry.last_interval_secs(),
     }
 }
 

tools/minilints/src/main.rs

@@ -255,9 +255,7 @@ fn check_for_unstaged_changes() {
 }
 
 fn generate_licences() -> Result<String> {
-    if which::which("cargo-license").is_err() {
+    Command::run("cargo install cargo-license@0.7.0")?;
-        Command::run("cargo install cargo-license@0.5.1")?;
-    }
     let output = Command::run_with_output([
         "cargo-license",
         "--features",

ts/lib/components/HelpModal.svelte

@@ -23,6 +23,7 @@ License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
 
     export let title: string;
     export let url: string;
+    export let linkLabel: string | undefined = undefined;
     export let startIndex = 0;
     export let helpSections: HelpItem[];
     export let fsrs = false;
@@ -106,11 +107,7 @@ License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
                     <div class="chapter-redirect">
                         {@html renderMarkdown(
                             tr.helpForMoreInfo({
-                                link: `<a href="${url}" title="${tr.helpOpenManualChapter(
+                                link: `<a href="${url}" title="${tr.helpOpenManualChapter({ name: linkLabel ?? title })}">${linkLabel ?? title}</a>`,
-                                    {
-                                        name: title,
-                                    },
-                                )}">${title}</a>`,
                             }),
                         )}
                     </div>

ts/lib/tslib/help-page.ts

@@ -27,7 +27,8 @@ export const HelpPage = {
         limitsFromTop: "https://docs.ankiweb.net/deck-options.html#limits-start-from-top",
         dailyLimits: "https://docs.ankiweb.net/deck-options.html#daily-limits",
         audio: "https://docs.ankiweb.net/deck-options.html#audio",
-        fsrs: "http://docs.ankiweb.net/deck-options.html#fsrs",
+        fsrs: "https://docs.ankiweb.net/deck-options.html#fsrs",
+        desiredRetention: "https://docs.ankiweb.net/deck-options.html#desired-retention",
     },
     Leeches: {
         leeches: "https://docs.ankiweb.net/leeches.html#leeches",

ts/routes/graphs/TrueRetention.svelte

@@ -72,7 +72,8 @@ License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
     >
         <HelpModal
             title={tr.statisticsTrueRetentionTitle()}
-            url={HelpPage.DeckOptions.fsrs}
+            url={HelpPage.DeckOptions.desiredRetention}
+            linkLabel={tr.deckConfigDesiredRetention()}
             {helpSections}
             on:mount={(e) => {
                 modal = e.detail.modal;

ts/routes/image-occlusion/Toolbar.svelte

@@ -32,6 +32,7 @@ License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
         saveNeededStore,
         opacityStateStore,
     } from "./store";
+    import { get } from "svelte/store";
     import { drawEllipse, drawPolygon, drawRectangle, drawText } from "./tools/index";
     import { makeMaskTransparent, SHAPE_MASK_COLOR } from "./tools/lib";
     import { enableSelectable, stopDraw } from "./tools/lib";
@@ -55,6 +56,7 @@ License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
         onWheelDragX,
     } from "./tools/tool-zoom";
     import { fillMask } from "./tools/tool-fill";
+    import { getCustomColours, saveCustomColours } from "@generated/backend";
 
     export let canvas;
     export let iconSize;
@@ -76,6 +78,16 @@ License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
     let colourRef: HTMLInputElement | undefined;
     const colour = writable(SHAPE_MASK_COLOR);
 
+    const customColorPickerPalette = writable<string[]>([]);
+
+    async function loadCustomColours() {
+        customColorPickerPalette.set(
+            (await getCustomColours({})).colours.filter(
+                (hex) => !hex.startsWith("#ffffff"),
+            ),
+        );
+    }
+
     function onClick(event: MouseEvent) {
         const upperCanvas = document.querySelector(".upper-canvas");
         if (event.target == upperCanvas) {
@@ -222,7 +234,7 @@ License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
     }
 
     onMount(() => {
-        opacityStateStore.set(maskOpacity);
+        maskOpacity = get(opacityStateStore);
         removeHandlers = singleCallback(
             on(document, "click", onClick),
             on(window, "mousemove", onMousemove),
@@ -233,6 +245,7 @@ License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
             on(document, "touchstart", onTouchstart),
             on(document, "mousemove", onMousemoveDocument),
         );
+        loadCustomColours();
     });
 
     onDestroy(() => {
@@ -241,7 +254,10 @@ License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
 </script>
 
 <datalist id="colour-palette">
-    <option value={SHAPE_MASK_COLOR}></option>
+    <option>{SHAPE_MASK_COLOR}</option>
+    {#each $customColorPickerPalette as colour}
+        <option>{colour}</option>
+    {/each}
 </datalist>
 
 <input
@@ -251,6 +267,7 @@ License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
     list="colour-palette"
     value={SHAPE_MASK_COLOR}
     on:input={(e) => ($colour = e.currentTarget!.value)}
+    on:change={() => saveCustomColours({})}
 />
 
 <div class="tool-bar-container" style:--fill-tool-colour={$colour}>

ts/routes/image-occlusion/mask-editor.ts

@@ -8,10 +8,22 @@ import { fabric } from "fabric";
 import { get } from "svelte/store";
 
 import { optimumCssSizeForCanvas } from "./canvas-scale";
-import { hideAllGuessOne, notesDataStore, saveNeededStore, tagsWritable, textEditingState } from "./store";
+import {
+    hideAllGuessOne,
+    notesDataStore,
+    opacityStateStore,
+    saveNeededStore,
+    tagsWritable,
+    textEditingState,
+} from "./store";
 import Toast from "./Toast.svelte";
 import { addShapesToCanvasFromCloze } from "./tools/add-from-cloze";
-import { enableSelectable, makeShapesRemainInCanvas, moveShapeToCanvasBoundaries } from "./tools/lib";
+import {
+    enableSelectable,
+    makeMaskTransparent,
+    makeShapesRemainInCanvas,
+    moveShapeToCanvasBoundaries,
+} from "./tools/lib";
 import { modifiedPolygon } from "./tools/tool-polygon";
 import { undoStack } from "./tools/tool-undo-redo";
 import { enablePinchZoom, onResize, setCanvasSize } from "./tools/tool-zoom";
@@ -83,6 +95,7 @@ export const setupMaskEditorForEdit = async (
         window.requestAnimationFrame(() => {
             onImageLoaded({ noteId: BigInt(noteId) });
         });
+        if (get(opacityStateStore)) { makeMaskTransparent(canvas, true); }
     };
 
     return canvas;