From cc2fb23b2e48b795b8c14246f52da4f2e1d839e8 Mon Sep 17 00:00:00 2001 From: diffwireauto <330573775+diffwireauto@users.noreply.github.com> Date: Thu, 22 Oct 2026 22:48:51 -0400 Subject: [PATCH] feat(#966): Clear Stale History Now, with refusals reported Epic B of #962. The manual trigger for Epic A's sweep, so a user does not wait 30 days. It passes olderThan: Duration.zero, which skips the WAIT and not the safety: the per-key verification inside reclaimVerifiedHistoryBlob is unchanged, proved by a test that Duration.zero still refuses a key whose rows cannot be verified. Its own widget rather than another card in app_settings_view.dart, which is already past a thousand lines, and so the tests can drive it without standing up the whole settings screen. Stateful against the repo's usual StatelessWidget-plus-Consumer habit, because the running flag and the last result are local to this card and belong to no service. The sweep is INJECTED, and that is a finding rather than a convenience. The first version of the widget test called the real sweep and hung past ten minutes instead of failing: the sweep uses compute, and an isolate deadlocks pumpAndSettle inside flutter_test's fake-async zone. A widget test should test the widget. So the card takes the sweep and the size read as parameters, the nine widget tests feed outcomes in directly, and the two new tests in stale_history_sweep_test.dart keep the injected semantic honest under plain test() where isolates work. Owner decision 2026-10-22, and the reason this Epic exists: the button REPORTS keys it refused, it does not only log them. "Cleared 1 old copies, 16.0 MB returned" and "Kept 1 that could not be verified" are both shown, including when a refusal is the reason nothing was cleared, which is the most important case to surface rather than the least. The automatic sweep stays log-only. Two Gemini findings, both fixed: - A fast double tap ran two sweeps. The disabled button is not enough on its own, because setState only SCHEDULES a rebuild, so two taps inside one frame both see a live onPressed. _clear now returns early on _running, and a test taps twice in one frame and asserts the sweep ran once. Two concurrent sweeps would have meant two concurrent VACUUMs. - A throw after real deletes was reported as a total failure. The honest fix was in the sweep, not the string: a successful sweep must not become an error because the closing size read threw, so that read now falls back to bytesBefore, which understates the reclaimed figure rather than inventing one. The failure string no longer claims nothing happened either. Strings are English-only, as everywhere else here: gen-l10n falls back to the template locale, and untranslated.json records the 9 keys across 17 locales, which is what that tracked file is for. 29 tests in the two files, full suite 1,483 pass, 1 skipped. analyze clean, format clean. Task: meshcore-open-gan Agent Mail: TealGlen Co-Authored-By: Claude Opus 5 --- lib/l10n/app_en.arb | 44 +++- lib/l10n/app_localizations.dart | 54 +++++ lib/l10n/app_localizations_bg.dart | 35 +++ lib/l10n/app_localizations_de.dart | 35 +++ lib/l10n/app_localizations_en.dart | 35 +++ lib/l10n/app_localizations_es.dart | 35 +++ lib/l10n/app_localizations_fr.dart | 35 +++ lib/l10n/app_localizations_hu.dart | 35 +++ lib/l10n/app_localizations_it.dart | 35 +++ lib/l10n/app_localizations_ja.dart | 35 +++ lib/l10n/app_localizations_ko.dart | 35 +++ lib/l10n/app_localizations_nl.dart | 35 +++ lib/l10n/app_localizations_pl.dart | 35 +++ lib/l10n/app_localizations_pt.dart | 35 +++ lib/l10n/app_localizations_ru.dart | 35 +++ lib/l10n/app_localizations_sk.dart | 35 +++ lib/l10n/app_localizations_sl.dart | 35 +++ lib/l10n/app_localizations_sv.dart | 35 +++ lib/l10n/app_localizations_uk.dart | 35 +++ lib/l10n/app_localizations_zh.dart | 35 +++ lib/screens/settings/app_settings_view.dart | 7 +- lib/services/stale_history_sweep.dart | 19 +- lib/widgets/storage_reclaim_card.dart | 185 ++++++++++++++++ test/storage/stale_history_sweep_test.dart | 44 ++++ test/widgets/storage_reclaim_card_test.dart | 225 ++++++++++++++++++++ untranslated.json | 221 +++++++++++++++++-- 26 files changed, 1409 insertions(+), 20 deletions(-) create mode 100644 lib/widgets/storage_reclaim_card.dart create mode 100644 test/widgets/storage_reclaim_card_test.dart diff --git a/lib/l10n/app_en.arb b/lib/l10n/app_en.arb index 63e896cb..22e097ac 100644 --- a/lib/l10n/app_en.arb +++ b/lib/l10n/app_en.arb @@ -3297,5 +3297,47 @@ "setRegionScope_save": "Save", "setRegionScope_searchRepeaters": "Search repeaters", "setRegionScope_pathNote": "You can only discover regions from a repeater you have a stored path to.", - "setRegionScope_noPath": "No stored path" + "setRegionScope_noPath": "No stored path", + "storage_title": "Storage", + "storage_databaseSize": "Message database: {size}", + "@storage_databaseSize": { + "description": "Current size of the message database on this device (#962).", + "placeholders": { + "size": { + "type": "String" + } + } + }, + "storage_staleHint": "When your history moves to the new format, the old copy is kept for 30 days and then cleared on its own. You can clear it now instead.", + "@storage_staleHint": { + "description": "Explains what the Clear Stale History action does (#962)." + }, + "storage_clearStaleNow": "Clear Stale History Now", + "storage_working": "Clearing...", + "storage_resultNothing": "Nothing to clear.", + "storage_resultCleared": "Cleared {count} old copies, {size} returned.", + "@storage_resultCleared": { + "description": "Result of a successful stale-history clear (#962).", + "placeholders": { + "count": { + "type": "int" + }, + "size": { + "type": "String" + } + } + }, + "storage_resultRefused": "Kept {count} that could not be verified. Your messages are intact; nothing was deleted for those.", + "@storage_resultRefused": { + "description": "Reported when the clear kept a copy back because its messages could not be verified against the new format (#962, owner decision: the button reports refusals rather than only logging them).", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "storage_resultFailed": "Could not finish, and some old copies may already have been cleared. Nothing was deleted that was not verified first, so your messages are intact.", + "@storage_resultFailed": { + "description": "Shown when the clear threw. It must not claim nothing happened, because the sweep deletes per key and may have cleared some before failing (#962)." + } } diff --git a/lib/l10n/app_localizations.dart b/lib/l10n/app_localizations.dart index 687451e3..1106cb50 100644 --- a/lib/l10n/app_localizations.dart +++ b/lib/l10n/app_localizations.dart @@ -9177,6 +9177,60 @@ abstract class AppLocalizations { /// In en, this message translates to: /// **'No stored path'** String get setRegionScope_noPath; + + /// No description provided for @storage_title. + /// + /// In en, this message translates to: + /// **'Storage'** + String get storage_title; + + /// Current size of the message database on this device (#962). + /// + /// In en, this message translates to: + /// **'Message database: {size}'** + String storage_databaseSize(String size); + + /// Explains what the Clear Stale History action does (#962). + /// + /// In en, this message translates to: + /// **'When your history moves to the new format, the old copy is kept for 30 days and then cleared on its own. You can clear it now instead.'** + String get storage_staleHint; + + /// No description provided for @storage_clearStaleNow. + /// + /// In en, this message translates to: + /// **'Clear Stale History Now'** + String get storage_clearStaleNow; + + /// No description provided for @storage_working. + /// + /// In en, this message translates to: + /// **'Clearing...'** + String get storage_working; + + /// No description provided for @storage_resultNothing. + /// + /// In en, this message translates to: + /// **'Nothing to clear.'** + String get storage_resultNothing; + + /// Result of a successful stale-history clear (#962). + /// + /// In en, this message translates to: + /// **'Cleared {count} old copies, {size} returned.'** + String storage_resultCleared(int count, String size); + + /// Reported when the clear kept a copy back because its messages could not be verified against the new format (#962, owner decision: the button reports refusals rather than only logging them). + /// + /// In en, this message translates to: + /// **'Kept {count} that could not be verified. Your messages are intact; nothing was deleted for those.'** + String storage_resultRefused(int count); + + /// Shown when the clear threw. It must not claim nothing happened, because the sweep deletes per key and may have cleared some before failing (#962). + /// + /// In en, this message translates to: + /// **'Could not finish, and some old copies may already have been cleared. Nothing was deleted that was not verified first, so your messages are intact.'** + String get storage_resultFailed; } class _AppLocalizationsDelegate diff --git a/lib/l10n/app_localizations_bg.dart b/lib/l10n/app_localizations_bg.dart index 756d6fad..177cc3ea 100644 --- a/lib/l10n/app_localizations_bg.dart +++ b/lib/l10n/app_localizations_bg.dart @@ -5424,4 +5424,39 @@ class AppLocalizationsBg extends AppLocalizations { @override String get setRegionScope_noPath => 'No stored path'; + + @override + String get storage_title => 'Storage'; + + @override + String storage_databaseSize(String size) { + return 'Message database: $size'; + } + + @override + String get storage_staleHint => + 'When your history moves to the new format, the old copy is kept for 30 days and then cleared on its own. You can clear it now instead.'; + + @override + String get storage_clearStaleNow => 'Clear Stale History Now'; + + @override + String get storage_working => 'Clearing...'; + + @override + String get storage_resultNothing => 'Nothing to clear.'; + + @override + String storage_resultCleared(int count, String size) { + return 'Cleared $count old copies, $size returned.'; + } + + @override + String storage_resultRefused(int count) { + return 'Kept $count that could not be verified. Your messages are intact; nothing was deleted for those.'; + } + + @override + String get storage_resultFailed => + 'Could not finish, and some old copies may already have been cleared. Nothing was deleted that was not verified first, so your messages are intact.'; } diff --git a/lib/l10n/app_localizations_de.dart b/lib/l10n/app_localizations_de.dart index 5a7b6e50..37c45011 100644 --- a/lib/l10n/app_localizations_de.dart +++ b/lib/l10n/app_localizations_de.dart @@ -5441,4 +5441,39 @@ class AppLocalizationsDe extends AppLocalizations { @override String get setRegionScope_noPath => 'No stored path'; + + @override + String get storage_title => 'Storage'; + + @override + String storage_databaseSize(String size) { + return 'Message database: $size'; + } + + @override + String get storage_staleHint => + 'When your history moves to the new format, the old copy is kept for 30 days and then cleared on its own. You can clear it now instead.'; + + @override + String get storage_clearStaleNow => 'Clear Stale History Now'; + + @override + String get storage_working => 'Clearing...'; + + @override + String get storage_resultNothing => 'Nothing to clear.'; + + @override + String storage_resultCleared(int count, String size) { + return 'Cleared $count old copies, $size returned.'; + } + + @override + String storage_resultRefused(int count) { + return 'Kept $count that could not be verified. Your messages are intact; nothing was deleted for those.'; + } + + @override + String get storage_resultFailed => + 'Could not finish, and some old copies may already have been cleared. Nothing was deleted that was not verified first, so your messages are intact.'; } diff --git a/lib/l10n/app_localizations_en.dart b/lib/l10n/app_localizations_en.dart index ed3d5d5b..9a421213 100644 --- a/lib/l10n/app_localizations_en.dart +++ b/lib/l10n/app_localizations_en.dart @@ -5347,4 +5347,39 @@ class AppLocalizationsEn extends AppLocalizations { @override String get setRegionScope_noPath => 'No stored path'; + + @override + String get storage_title => 'Storage'; + + @override + String storage_databaseSize(String size) { + return 'Message database: $size'; + } + + @override + String get storage_staleHint => + 'When your history moves to the new format, the old copy is kept for 30 days and then cleared on its own. You can clear it now instead.'; + + @override + String get storage_clearStaleNow => 'Clear Stale History Now'; + + @override + String get storage_working => 'Clearing...'; + + @override + String get storage_resultNothing => 'Nothing to clear.'; + + @override + String storage_resultCleared(int count, String size) { + return 'Cleared $count old copies, $size returned.'; + } + + @override + String storage_resultRefused(int count) { + return 'Kept $count that could not be verified. Your messages are intact; nothing was deleted for those.'; + } + + @override + String get storage_resultFailed => + 'Could not finish, and some old copies may already have been cleared. Nothing was deleted that was not verified first, so your messages are intact.'; } diff --git a/lib/l10n/app_localizations_es.dart b/lib/l10n/app_localizations_es.dart index c4afa3e5..9231b7a8 100644 --- a/lib/l10n/app_localizations_es.dart +++ b/lib/l10n/app_localizations_es.dart @@ -5429,4 +5429,39 @@ class AppLocalizationsEs extends AppLocalizations { @override String get setRegionScope_noPath => 'No stored path'; + + @override + String get storage_title => 'Storage'; + + @override + String storage_databaseSize(String size) { + return 'Message database: $size'; + } + + @override + String get storage_staleHint => + 'When your history moves to the new format, the old copy is kept for 30 days and then cleared on its own. You can clear it now instead.'; + + @override + String get storage_clearStaleNow => 'Clear Stale History Now'; + + @override + String get storage_working => 'Clearing...'; + + @override + String get storage_resultNothing => 'Nothing to clear.'; + + @override + String storage_resultCleared(int count, String size) { + return 'Cleared $count old copies, $size returned.'; + } + + @override + String storage_resultRefused(int count) { + return 'Kept $count that could not be verified. Your messages are intact; nothing was deleted for those.'; + } + + @override + String get storage_resultFailed => + 'Could not finish, and some old copies may already have been cleared. Nothing was deleted that was not verified first, so your messages are intact.'; } diff --git a/lib/l10n/app_localizations_fr.dart b/lib/l10n/app_localizations_fr.dart index 6b54ae04..f1081257 100644 --- a/lib/l10n/app_localizations_fr.dart +++ b/lib/l10n/app_localizations_fr.dart @@ -5457,4 +5457,39 @@ class AppLocalizationsFr extends AppLocalizations { @override String get setRegionScope_noPath => 'No stored path'; + + @override + String get storage_title => 'Storage'; + + @override + String storage_databaseSize(String size) { + return 'Message database: $size'; + } + + @override + String get storage_staleHint => + 'When your history moves to the new format, the old copy is kept for 30 days and then cleared on its own. You can clear it now instead.'; + + @override + String get storage_clearStaleNow => 'Clear Stale History Now'; + + @override + String get storage_working => 'Clearing...'; + + @override + String get storage_resultNothing => 'Nothing to clear.'; + + @override + String storage_resultCleared(int count, String size) { + return 'Cleared $count old copies, $size returned.'; + } + + @override + String storage_resultRefused(int count) { + return 'Kept $count that could not be verified. Your messages are intact; nothing was deleted for those.'; + } + + @override + String get storage_resultFailed => + 'Could not finish, and some old copies may already have been cleared. Nothing was deleted that was not verified first, so your messages are intact.'; } diff --git a/lib/l10n/app_localizations_hu.dart b/lib/l10n/app_localizations_hu.dart index a65b1356..be57d319 100644 --- a/lib/l10n/app_localizations_hu.dart +++ b/lib/l10n/app_localizations_hu.dart @@ -5446,4 +5446,39 @@ class AppLocalizationsHu extends AppLocalizations { @override String get setRegionScope_noPath => 'No stored path'; + + @override + String get storage_title => 'Storage'; + + @override + String storage_databaseSize(String size) { + return 'Message database: $size'; + } + + @override + String get storage_staleHint => + 'When your history moves to the new format, the old copy is kept for 30 days and then cleared on its own. You can clear it now instead.'; + + @override + String get storage_clearStaleNow => 'Clear Stale History Now'; + + @override + String get storage_working => 'Clearing...'; + + @override + String get storage_resultNothing => 'Nothing to clear.'; + + @override + String storage_resultCleared(int count, String size) { + return 'Cleared $count old copies, $size returned.'; + } + + @override + String storage_resultRefused(int count) { + return 'Kept $count that could not be verified. Your messages are intact; nothing was deleted for those.'; + } + + @override + String get storage_resultFailed => + 'Could not finish, and some old copies may already have been cleared. Nothing was deleted that was not verified first, so your messages are intact.'; } diff --git a/lib/l10n/app_localizations_it.dart b/lib/l10n/app_localizations_it.dart index 68693e6a..d9765386 100644 --- a/lib/l10n/app_localizations_it.dart +++ b/lib/l10n/app_localizations_it.dart @@ -5434,4 +5434,39 @@ class AppLocalizationsIt extends AppLocalizations { @override String get setRegionScope_noPath => 'No stored path'; + + @override + String get storage_title => 'Storage'; + + @override + String storage_databaseSize(String size) { + return 'Message database: $size'; + } + + @override + String get storage_staleHint => + 'When your history moves to the new format, the old copy is kept for 30 days and then cleared on its own. You can clear it now instead.'; + + @override + String get storage_clearStaleNow => 'Clear Stale History Now'; + + @override + String get storage_working => 'Clearing...'; + + @override + String get storage_resultNothing => 'Nothing to clear.'; + + @override + String storage_resultCleared(int count, String size) { + return 'Cleared $count old copies, $size returned.'; + } + + @override + String storage_resultRefused(int count) { + return 'Kept $count that could not be verified. Your messages are intact; nothing was deleted for those.'; + } + + @override + String get storage_resultFailed => + 'Could not finish, and some old copies may already have been cleared. Nothing was deleted that was not verified first, so your messages are intact.'; } diff --git a/lib/l10n/app_localizations_ja.dart b/lib/l10n/app_localizations_ja.dart index b962df0d..9271f9cd 100644 --- a/lib/l10n/app_localizations_ja.dart +++ b/lib/l10n/app_localizations_ja.dart @@ -5200,4 +5200,39 @@ class AppLocalizationsJa extends AppLocalizations { @override String get setRegionScope_noPath => 'No stored path'; + + @override + String get storage_title => 'Storage'; + + @override + String storage_databaseSize(String size) { + return 'Message database: $size'; + } + + @override + String get storage_staleHint => + 'When your history moves to the new format, the old copy is kept for 30 days and then cleared on its own. You can clear it now instead.'; + + @override + String get storage_clearStaleNow => 'Clear Stale History Now'; + + @override + String get storage_working => 'Clearing...'; + + @override + String get storage_resultNothing => 'Nothing to clear.'; + + @override + String storage_resultCleared(int count, String size) { + return 'Cleared $count old copies, $size returned.'; + } + + @override + String storage_resultRefused(int count) { + return 'Kept $count that could not be verified. Your messages are intact; nothing was deleted for those.'; + } + + @override + String get storage_resultFailed => + 'Could not finish, and some old copies may already have been cleared. Nothing was deleted that was not verified first, so your messages are intact.'; } diff --git a/lib/l10n/app_localizations_ko.dart b/lib/l10n/app_localizations_ko.dart index 3784b076..2a466483 100644 --- a/lib/l10n/app_localizations_ko.dart +++ b/lib/l10n/app_localizations_ko.dart @@ -5201,4 +5201,39 @@ class AppLocalizationsKo extends AppLocalizations { @override String get setRegionScope_noPath => 'No stored path'; + + @override + String get storage_title => 'Storage'; + + @override + String storage_databaseSize(String size) { + return 'Message database: $size'; + } + + @override + String get storage_staleHint => + 'When your history moves to the new format, the old copy is kept for 30 days and then cleared on its own. You can clear it now instead.'; + + @override + String get storage_clearStaleNow => 'Clear Stale History Now'; + + @override + String get storage_working => 'Clearing...'; + + @override + String get storage_resultNothing => 'Nothing to clear.'; + + @override + String storage_resultCleared(int count, String size) { + return 'Cleared $count old copies, $size returned.'; + } + + @override + String storage_resultRefused(int count) { + return 'Kept $count that could not be verified. Your messages are intact; nothing was deleted for those.'; + } + + @override + String get storage_resultFailed => + 'Could not finish, and some old copies may already have been cleared. Nothing was deleted that was not verified first, so your messages are intact.'; } diff --git a/lib/l10n/app_localizations_nl.dart b/lib/l10n/app_localizations_nl.dart index 95f297c7..9ba517a1 100644 --- a/lib/l10n/app_localizations_nl.dart +++ b/lib/l10n/app_localizations_nl.dart @@ -5409,4 +5409,39 @@ class AppLocalizationsNl extends AppLocalizations { @override String get setRegionScope_noPath => 'No stored path'; + + @override + String get storage_title => 'Storage'; + + @override + String storage_databaseSize(String size) { + return 'Message database: $size'; + } + + @override + String get storage_staleHint => + 'When your history moves to the new format, the old copy is kept for 30 days and then cleared on its own. You can clear it now instead.'; + + @override + String get storage_clearStaleNow => 'Clear Stale History Now'; + + @override + String get storage_working => 'Clearing...'; + + @override + String get storage_resultNothing => 'Nothing to clear.'; + + @override + String storage_resultCleared(int count, String size) { + return 'Cleared $count old copies, $size returned.'; + } + + @override + String storage_resultRefused(int count) { + return 'Kept $count that could not be verified. Your messages are intact; nothing was deleted for those.'; + } + + @override + String get storage_resultFailed => + 'Could not finish, and some old copies may already have been cleared. Nothing was deleted that was not verified first, so your messages are intact.'; } diff --git a/lib/l10n/app_localizations_pl.dart b/lib/l10n/app_localizations_pl.dart index ed78bfb6..87f72c30 100644 --- a/lib/l10n/app_localizations_pl.dart +++ b/lib/l10n/app_localizations_pl.dart @@ -5446,4 +5446,39 @@ class AppLocalizationsPl extends AppLocalizations { @override String get setRegionScope_noPath => 'No stored path'; + + @override + String get storage_title => 'Storage'; + + @override + String storage_databaseSize(String size) { + return 'Message database: $size'; + } + + @override + String get storage_staleHint => + 'When your history moves to the new format, the old copy is kept for 30 days and then cleared on its own. You can clear it now instead.'; + + @override + String get storage_clearStaleNow => 'Clear Stale History Now'; + + @override + String get storage_working => 'Clearing...'; + + @override + String get storage_resultNothing => 'Nothing to clear.'; + + @override + String storage_resultCleared(int count, String size) { + return 'Cleared $count old copies, $size returned.'; + } + + @override + String storage_resultRefused(int count) { + return 'Kept $count that could not be verified. Your messages are intact; nothing was deleted for those.'; + } + + @override + String get storage_resultFailed => + 'Could not finish, and some old copies may already have been cleared. Nothing was deleted that was not verified first, so your messages are intact.'; } diff --git a/lib/l10n/app_localizations_pt.dart b/lib/l10n/app_localizations_pt.dart index 83faa2b7..0e4a7910 100644 --- a/lib/l10n/app_localizations_pt.dart +++ b/lib/l10n/app_localizations_pt.dart @@ -5422,4 +5422,39 @@ class AppLocalizationsPt extends AppLocalizations { @override String get setRegionScope_noPath => 'No stored path'; + + @override + String get storage_title => 'Storage'; + + @override + String storage_databaseSize(String size) { + return 'Message database: $size'; + } + + @override + String get storage_staleHint => + 'When your history moves to the new format, the old copy is kept for 30 days and then cleared on its own. You can clear it now instead.'; + + @override + String get storage_clearStaleNow => 'Clear Stale History Now'; + + @override + String get storage_working => 'Clearing...'; + + @override + String get storage_resultNothing => 'Nothing to clear.'; + + @override + String storage_resultCleared(int count, String size) { + return 'Cleared $count old copies, $size returned.'; + } + + @override + String storage_resultRefused(int count) { + return 'Kept $count that could not be verified. Your messages are intact; nothing was deleted for those.'; + } + + @override + String get storage_resultFailed => + 'Could not finish, and some old copies may already have been cleared. Nothing was deleted that was not verified first, so your messages are intact.'; } diff --git a/lib/l10n/app_localizations_ru.dart b/lib/l10n/app_localizations_ru.dart index f85d1072..7da39ce6 100644 --- a/lib/l10n/app_localizations_ru.dart +++ b/lib/l10n/app_localizations_ru.dart @@ -5440,4 +5440,39 @@ class AppLocalizationsRu extends AppLocalizations { @override String get setRegionScope_noPath => 'No stored path'; + + @override + String get storage_title => 'Storage'; + + @override + String storage_databaseSize(String size) { + return 'Message database: $size'; + } + + @override + String get storage_staleHint => + 'When your history moves to the new format, the old copy is kept for 30 days and then cleared on its own. You can clear it now instead.'; + + @override + String get storage_clearStaleNow => 'Clear Stale History Now'; + + @override + String get storage_working => 'Clearing...'; + + @override + String get storage_resultNothing => 'Nothing to clear.'; + + @override + String storage_resultCleared(int count, String size) { + return 'Cleared $count old copies, $size returned.'; + } + + @override + String storage_resultRefused(int count) { + return 'Kept $count that could not be verified. Your messages are intact; nothing was deleted for those.'; + } + + @override + String get storage_resultFailed => + 'Could not finish, and some old copies may already have been cleared. Nothing was deleted that was not verified first, so your messages are intact.'; } diff --git a/lib/l10n/app_localizations_sk.dart b/lib/l10n/app_localizations_sk.dart index b7b7a602..3fb0c77b 100644 --- a/lib/l10n/app_localizations_sk.dart +++ b/lib/l10n/app_localizations_sk.dart @@ -5406,4 +5406,39 @@ class AppLocalizationsSk extends AppLocalizations { @override String get setRegionScope_noPath => 'No stored path'; + + @override + String get storage_title => 'Storage'; + + @override + String storage_databaseSize(String size) { + return 'Message database: $size'; + } + + @override + String get storage_staleHint => + 'When your history moves to the new format, the old copy is kept for 30 days and then cleared on its own. You can clear it now instead.'; + + @override + String get storage_clearStaleNow => 'Clear Stale History Now'; + + @override + String get storage_working => 'Clearing...'; + + @override + String get storage_resultNothing => 'Nothing to clear.'; + + @override + String storage_resultCleared(int count, String size) { + return 'Cleared $count old copies, $size returned.'; + } + + @override + String storage_resultRefused(int count) { + return 'Kept $count that could not be verified. Your messages are intact; nothing was deleted for those.'; + } + + @override + String get storage_resultFailed => + 'Could not finish, and some old copies may already have been cleared. Nothing was deleted that was not verified first, so your messages are intact.'; } diff --git a/lib/l10n/app_localizations_sl.dart b/lib/l10n/app_localizations_sl.dart index 757f3134..970574ec 100644 --- a/lib/l10n/app_localizations_sl.dart +++ b/lib/l10n/app_localizations_sl.dart @@ -5404,4 +5404,39 @@ class AppLocalizationsSl extends AppLocalizations { @override String get setRegionScope_noPath => 'No stored path'; + + @override + String get storage_title => 'Storage'; + + @override + String storage_databaseSize(String size) { + return 'Message database: $size'; + } + + @override + String get storage_staleHint => + 'When your history moves to the new format, the old copy is kept for 30 days and then cleared on its own. You can clear it now instead.'; + + @override + String get storage_clearStaleNow => 'Clear Stale History Now'; + + @override + String get storage_working => 'Clearing...'; + + @override + String get storage_resultNothing => 'Nothing to clear.'; + + @override + String storage_resultCleared(int count, String size) { + return 'Cleared $count old copies, $size returned.'; + } + + @override + String storage_resultRefused(int count) { + return 'Kept $count that could not be verified. Your messages are intact; nothing was deleted for those.'; + } + + @override + String get storage_resultFailed => + 'Could not finish, and some old copies may already have been cleared. Nothing was deleted that was not verified first, so your messages are intact.'; } diff --git a/lib/l10n/app_localizations_sv.dart b/lib/l10n/app_localizations_sv.dart index 27115785..38bc2f4d 100644 --- a/lib/l10n/app_localizations_sv.dart +++ b/lib/l10n/app_localizations_sv.dart @@ -5379,4 +5379,39 @@ class AppLocalizationsSv extends AppLocalizations { @override String get setRegionScope_noPath => 'No stored path'; + + @override + String get storage_title => 'Storage'; + + @override + String storage_databaseSize(String size) { + return 'Message database: $size'; + } + + @override + String get storage_staleHint => + 'When your history moves to the new format, the old copy is kept for 30 days and then cleared on its own. You can clear it now instead.'; + + @override + String get storage_clearStaleNow => 'Clear Stale History Now'; + + @override + String get storage_working => 'Clearing...'; + + @override + String get storage_resultNothing => 'Nothing to clear.'; + + @override + String storage_resultCleared(int count, String size) { + return 'Cleared $count old copies, $size returned.'; + } + + @override + String storage_resultRefused(int count) { + return 'Kept $count that could not be verified. Your messages are intact; nothing was deleted for those.'; + } + + @override + String get storage_resultFailed => + 'Could not finish, and some old copies may already have been cleared. Nothing was deleted that was not verified first, so your messages are intact.'; } diff --git a/lib/l10n/app_localizations_uk.dart b/lib/l10n/app_localizations_uk.dart index 2b9611db..e0de749f 100644 --- a/lib/l10n/app_localizations_uk.dart +++ b/lib/l10n/app_localizations_uk.dart @@ -5441,4 +5441,39 @@ class AppLocalizationsUk extends AppLocalizations { @override String get setRegionScope_noPath => 'No stored path'; + + @override + String get storage_title => 'Storage'; + + @override + String storage_databaseSize(String size) { + return 'Message database: $size'; + } + + @override + String get storage_staleHint => + 'When your history moves to the new format, the old copy is kept for 30 days and then cleared on its own. You can clear it now instead.'; + + @override + String get storage_clearStaleNow => 'Clear Stale History Now'; + + @override + String get storage_working => 'Clearing...'; + + @override + String get storage_resultNothing => 'Nothing to clear.'; + + @override + String storage_resultCleared(int count, String size) { + return 'Cleared $count old copies, $size returned.'; + } + + @override + String storage_resultRefused(int count) { + return 'Kept $count that could not be verified. Your messages are intact; nothing was deleted for those.'; + } + + @override + String get storage_resultFailed => + 'Could not finish, and some old copies may already have been cleared. Nothing was deleted that was not verified first, so your messages are intact.'; } diff --git a/lib/l10n/app_localizations_zh.dart b/lib/l10n/app_localizations_zh.dart index 7bb28f30..d68664b8 100644 --- a/lib/l10n/app_localizations_zh.dart +++ b/lib/l10n/app_localizations_zh.dart @@ -5074,4 +5074,39 @@ class AppLocalizationsZh extends AppLocalizations { @override String get setRegionScope_noPath => 'No stored path'; + + @override + String get storage_title => 'Storage'; + + @override + String storage_databaseSize(String size) { + return 'Message database: $size'; + } + + @override + String get storage_staleHint => + 'When your history moves to the new format, the old copy is kept for 30 days and then cleared on its own. You can clear it now instead.'; + + @override + String get storage_clearStaleNow => 'Clear Stale History Now'; + + @override + String get storage_working => 'Clearing...'; + + @override + String get storage_resultNothing => 'Nothing to clear.'; + + @override + String storage_resultCleared(int count, String size) { + return 'Cleared $count old copies, $size returned.'; + } + + @override + String storage_resultRefused(int count) { + return 'Kept $count that could not be verified. Your messages are intact; nothing was deleted for those.'; + } + + @override + String get storage_resultFailed => + 'Could not finish, and some old copies may already have been cleared. Nothing was deleted that was not verified first, so your messages are intact.'; } diff --git a/lib/screens/settings/app_settings_view.dart b/lib/screens/settings/app_settings_view.dart index 5486422f..7fcfe8f7 100644 --- a/lib/screens/settings/app_settings_view.dart +++ b/lib/screens/settings/app_settings_view.dart @@ -11,11 +11,12 @@ import '../../services/app_settings_service.dart'; import '../../services/translation_service.dart'; import '../../helpers/settings_persist.dart'; import '../../helpers/snack_bar_builder.dart'; +import '../../widgets/storage_reclaim_card.dart'; import '../map_cache_screen.dart'; /// Embeddable view (no Scaffold) for the App Settings shell pane. /// -/// Renders appearance, translation, battery, map, and Cyr2Lat cards. +/// Renders appearance, translation, battery, map, Cyr2Lat and storage cards. /// Notifications and message-handling settings live in [MessageSettingsView]; /// app debug logging lives in the Debug category on the settings screen. class AppSettingsView extends StatelessWidget { @@ -44,6 +45,10 @@ class AppSettingsView extends StatelessWidget { _buildMapSettingsCard(context, settingsService), const SizedBox(height: 16), _buildCyr2LatCard(context, settingsService), + const SizedBox(height: 16), + // #962. Its own widget rather than another card in this file, + // which is already past a thousand lines. + const StorageReclaimCard(), ], ); }, diff --git a/lib/services/stale_history_sweep.dart b/lib/services/stale_history_sweep.dart index f4652cc4..2b42e21d 100644 --- a/lib/services/stale_history_sweep.dart +++ b/lib/services/stale_history_sweep.dart @@ -167,7 +167,24 @@ class StaleHistorySweep { } } - final bytesAfter = await _blobs.databaseSizeBytes(); + // A sweep that deleted blobs correctly must not be reported as a failure + // because the closing size read threw. The deletes are the work; the byte + // count is reporting. Falling back to `bytesBefore` makes the reclaimed + // figure read as 0, which understates rather than invents, and keeps the + // manual action from telling the user nothing happened when something did + // (Gemini review). + int bytesAfter; + try { + bytesAfter = await _blobs.databaseSizeBytes(); + } catch (e) { + appLogger.warn( + 'Cleared ${cleared.length} stale blob(s) but could not read the ' + 'database size afterwards, so the reclaimed figure reads as 0: $e', + tag: 'Storage', + ); + bytesAfter = bytesBefore; + } + if (cleared.isNotEmpty || refused.isNotEmpty) { appLogger.info( 'Stale history sweep: cleared ${cleared.length}, kept ' diff --git a/lib/widgets/storage_reclaim_card.dart b/lib/widgets/storage_reclaim_card.dart new file mode 100644 index 00000000..d34cfd50 --- /dev/null +++ b/lib/widgets/storage_reclaim_card.dart @@ -0,0 +1,185 @@ +import 'package:flutter/material.dart'; + +import '../l10n/app_localizations.dart'; +import '../l10n/l10n.dart'; +import '../services/stale_history_sweep.dart'; +import '../storage/drift/blob_store.dart'; +import '../utils/app_logger.dart'; + +/// "Clear Stale History Now": the manual trigger for the #962 sweep. +/// +/// A migrated message key keeps a frozen copy of its history, which the sweep +/// reclaims 30 days later on its own. This is for not waiting. +/// +/// Its own widget rather than another card inside `app_settings_view.dart`, +/// which is already past a thousand lines, and so that B2's tests can drive it +/// without standing up the whole settings screen. +/// +/// Stateful, against the repo's usual StatelessWidget-plus-Consumer habit, +/// because the running flag and the last result are local to this card and +/// belong to no service. +class StorageReclaimCard extends StatefulWidget { + const StorageReclaimCard({ + super.key, + BlobStore? blobs, + Future Function()? runSweep, + Future Function()? readSize, + }) : _blobs = blobs, + _runSweep = runSweep, + _readSize = readSize; + + /// Injectable for tests; production reads the singleton. + final BlobStore? _blobs; + + /// The sweep, injectable. + /// + /// Not only for convenience: the real sweep uses `compute`, and an isolate + /// deadlocks `pumpAndSettle` inside `flutter_test`'s fake-async zone. The + /// sweep's own behaviour is covered by Epic A's unit tests, which run under + /// plain `test()` where isolates work. What is left to prove here is that + /// this card reports each outcome correctly, and that is testable without + /// re-running the engine. + final Future Function()? _runSweep; + + /// The size read, injectable for the same reason. + final Future Function()? _readSize; + + @override + State createState() => _StorageReclaimCardState(); +} + +class _StorageReclaimCardState extends State { + BlobStore get _blobs => widget._blobs ?? BlobStore.instance; + + bool _running = false; + int? _sizeBytes; + StaleHistoryOutcome? _result; + Object? _error; + + @override + void initState() { + super.initState(); + _refreshSize(); + } + + Future _refreshSize() async { + try { + final size = await (widget._readSize ?? _blobs.databaseSizeBytes)(); + if (mounted) setState(() => _sizeBytes = size); + } catch (e) { + // A size we cannot read is not worth an error state: the action below + // still works, and the row simply shows nothing. + appLogger.warn('Could not read the database size: $e', tag: 'Storage'); + } + } + + Future _clear() async { + // The disabled button is not enough on its own. `setState` only schedules + // a rebuild, so two taps inside one frame both see an `onPressed` that is + // still non-null and both reach here, which would run two sweeps and two + // VACUUMs concurrently (Gemini review). + if (_running) return; + setState(() { + _running = true; + _result = null; + _error = null; + }); + try { + // `olderThan: Duration.zero` is the whole point of the button: every + // migrated key is eligible immediately. The per-key verification is + // unchanged, so this skips the wait and not the safety. + final outcome = + await (widget._runSweep ?? + () => StaleHistorySweep(_blobs).run(olderThan: Duration.zero))(); + if (!mounted) return; + setState(() { + _result = outcome; + _sizeBytes = outcome.bytesAfter; + }); + } catch (e, s) { + appLogger.error('Clear stale history failed: $e\n$s', tag: 'Storage'); + if (!mounted) return; + setState(() => _error = e); + } finally { + if (mounted) setState(() => _running = false); + } + } + + static String _mb(int bytes) => + '${(bytes / (1024 * 1024)).toStringAsFixed(1)} MB'; + + @override + Widget build(BuildContext context) { + final l10n = context.l10n; + return Card( + child: Padding( + padding: const EdgeInsets.all(16), + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text( + l10n.storage_title, + style: const TextStyle(fontSize: 16, fontWeight: FontWeight.bold), + ), + const SizedBox(height: 8), + if (_sizeBytes != null) + Text(l10n.storage_databaseSize(_mb(_sizeBytes!))), + const SizedBox(height: 8), + Text( + l10n.storage_staleHint, + style: TextStyle(fontSize: 12, color: Colors.grey[600]), + ), + const SizedBox(height: 12), + Align( + alignment: Alignment.centerLeft, + child: FilledButton.tonal( + onPressed: _running ? null : _clear, + child: Text( + _running ? l10n.storage_working : l10n.storage_clearStaleNow, + ), + ), + ), + ?_resultLine(l10n), + ], + ), + ), + ); + } + + Widget? _resultLine(AppLocalizations l10n) { + if (_error != null) { + return Padding( + padding: const EdgeInsets.only(top: 12), + child: Text( + l10n.storage_resultFailed, + style: TextStyle(color: Theme.of(context).colorScheme.error), + ), + ); + } + final r = _result; + if (r == null) return null; + + final lines = [ + if (r.cleared.isEmpty) + l10n.storage_resultNothing + else + l10n.storage_resultCleared( + r.cleared.length, + _mb(r.bytesReclaimed < 0 ? 0 : r.bytesReclaimed), + ), + // Owner decision 2026-10-22: the button reports what it refused, it does + // not just log it. A key kept back because its rows could not be + // verified is the single most useful thing this action can tell you, and + // staying quiet about it is how #952 went unnoticed for days. + if (r.refused.isNotEmpty) l10n.storage_resultRefused(r.refused.length), + ]; + + return Padding( + padding: const EdgeInsets.only(top: 12), + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [for (final line in lines) Text(line)], + ), + ); + } +} diff --git a/test/storage/stale_history_sweep_test.dart b/test/storage/stale_history_sweep_test.dart index 1551716b..977620c1 100644 --- a/test/storage/stale_history_sweep_test.dart +++ b/test/storage/stale_history_sweep_test.dart @@ -369,6 +369,50 @@ void main() { }); }); + group('what the manual action relies on (#966)', () { + test('olderThan zero makes a key migrated seconds ago eligible', () async { + // The button passes Duration.zero, which is the whole point of it: no + // waiting 30 days. Proven here under plain `test()` rather than in the + // widget test, because the sweep uses `compute` and an isolate + // deadlocks pumpAndSettle in flutter_test's fake-async zone. The widget + // test injects the sweep for that reason, so this is what keeps the + // semantic it injects honest. + await blobs.write(key, bigBlobWith(20)); + expect(await blobs.ensureMessageRowsMigrated(key, toRows), isTrue); + + // The default window leaves it alone. + expect((await StaleHistorySweep(blobs).run()).cleared, isEmpty); + expect(await blobs.read(key), isNotNull); + + // Duration.zero does not. + final outcome = await StaleHistorySweep( + blobs, + ).run(olderThan: Duration.zero); + + expect(outcome.cleared, [key]); + expect(await blobs.read(key), isNull); + expect(await blobs.messageRowCount(key), 20); + }); + + test('olderThan zero still refuses an unverifiable key', () async { + // Skipping the wait must not skip the safety. + await blobs.write(key, bigBlobWith(20)); + await blobs.ensureMessageRowsMigrated(key, toRows); + await blobs.deleteMessageRow( + key, + (await blobs.messageMergeKeys(key)).first, + ); + + final outcome = await StaleHistorySweep( + blobs, + ).run(olderThan: Duration.zero); + + expect(outcome.cleared, isEmpty); + expect(outcome.refused, [key]); + expect(await blobs.read(key), isNotNull); + }); + }); + group('a direct-message key sweeps too', () { test('messages_ uses the DM converter and is cleared', () async { const dmKey = 'messages_aaaaaaaaaacafebabe'; diff --git a/test/widgets/storage_reclaim_card_test.dart b/test/widgets/storage_reclaim_card_test.dart new file mode 100644 index 00000000..c5d6f6b8 --- /dev/null +++ b/test/widgets/storage_reclaim_card_test.dart @@ -0,0 +1,225 @@ +import 'dart:async'; + +import 'package:flutter/material.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:meshcore_open/l10n/app_localizations.dart'; +import 'package:meshcore_open/services/stale_history_sweep.dart'; +import 'package:meshcore_open/widgets/storage_reclaim_card.dart'; + +/// Epic B of #962, task B2. +/// +/// Tests the CARD, not the sweep. The sweep's behaviour is pinned by Epic A's +/// 18 unit tests, which run under plain `test()`. It cannot be re-run here: +/// it uses `compute`, and an isolate deadlocks `pumpAndSettle` inside +/// `flutter_test`'s fake-async zone, which is what made the first version of +/// this file hang past ten minutes rather than fail. So the sweep is injected +/// and each outcome is fed in directly. +/// +/// The case this task exists for is the third one: a key held back because its +/// rows could not be verified must be REPORTED, not merely logged. Owner +/// decision 2026-10-22. +void main() { + StaleHistoryOutcome outcome({ + List cleared = const [], + List refused = const [], + int before = 70 * 1024 * 1024, + int after = 70 * 1024 * 1024, + }) => StaleHistoryOutcome( + cleared: cleared, + refused: refused, + bytesBefore: before, + bytesAfter: after, + ); + + Future pump( + WidgetTester tester, { + required Future Function() runSweep, + Future Function()? readSize, + }) async { + await tester.pumpWidget( + MaterialApp( + localizationsDelegates: AppLocalizations.localizationsDelegates, + supportedLocales: AppLocalizations.supportedLocales, + home: Scaffold( + body: StorageReclaimCard( + runSweep: runSweep, + readSize: readSize ?? () async => 70 * 1024 * 1024, + ), + ), + ), + ); + await tester.pumpAndSettle(); + } + + Future tapClear(WidgetTester tester) async { + await tester.tap(find.text('Clear Stale History Now')); + await tester.pumpAndSettle(); + } + + testWidgets('it shows the database size before anything is clicked', ( + tester, + ) async { + await pump(tester, runSweep: () async => outcome()); + + expect(find.textContaining('Message database:'), findsOneWidget); + expect(find.textContaining('70.0 MB'), findsOneWidget); + }); + + testWidgets('nothing eligible reports nothing to clear', (tester) async { + await pump(tester, runSweep: () async => outcome()); + + await tapClear(tester); + + expect(find.text('Nothing to clear.'), findsOneWidget); + expect(find.textContaining('Kept'), findsNothing); + }); + + testWidgets('cleared keys report the count and the size returned', ( + tester, + ) async { + await pump( + tester, + runSweep: () async => outcome( + cleared: const ['a', 'b', 'c'], + before: 70 * 1024 * 1024, + after: 54 * 1024 * 1024, + ), + ); + + await tapClear(tester); + + expect(find.textContaining('Cleared 3 old copies'), findsOneWidget); + expect(find.textContaining('16.0 MB returned'), findsOneWidget); + // And the size row updates to what the sweep actually left behind, rather + // than still showing the pre-sweep number. + expect(find.textContaining('Message database: 54.0 MB'), findsOneWidget); + }); + + testWidgets('a refused key is REPORTED, not just logged', (tester) async { + await pump( + tester, + runSweep: () async => outcome(cleared: const ['a'], refused: const ['b']), + ); + + await tapClear(tester); + + expect( + find.textContaining('Kept 1 that could not be verified'), + findsOneWidget, + reason: 'silence here is how #952 went unnoticed for days', + ); + expect( + find.textContaining('messages are intact'), + findsOneWidget, + reason: + 'it has to say the history is safe, not only that something was ' + 'held back', + ); + // Both halves are shown: what went and what did not. + expect(find.textContaining('Cleared 1 old copies'), findsOneWidget); + }); + + testWidgets('refusals show even when nothing at all was cleared', ( + tester, + ) async { + await pump(tester, runSweep: () async => outcome(refused: const ['b'])); + + await tapClear(tester); + + expect(find.text('Nothing to clear.'), findsOneWidget); + expect( + find.textContaining('Kept 1 that could not be verified'), + findsOneWidget, + reason: + 'a run that cleared nothing BECAUSE of a refusal is the most ' + 'important case to surface, not the least', + ); + }); + + testWidgets('a failure says the messages are intact', (tester) async { + // "Could not finish" on a delete action otherwise reads as "something was + // half-deleted". + await pump(tester, runSweep: () async => throw StateError('boom')); + + await tapClear(tester); + + expect(find.textContaining('Could not finish'), findsOneWidget); + expect(find.textContaining('messages are intact'), findsOneWidget); + expect( + find.textContaining('may already have been cleared'), + findsOneWidget, + reason: + 'the sweep deletes per key, so a throw can follow real deletes and ' + 'the message must not claim nothing happened (Gemini review)', + ); + }); + + testWidgets('a second tap in the same frame cannot start a second sweep', ( + tester, + ) async { + // The disabled button is not enough: setState only SCHEDULES a rebuild, + // so two taps inside one frame both see a live onPressed. _clear guards + // on _running for that, and two concurrent sweeps would mean two + // concurrent VACUUMs. + var runs = 0; + final gate = Completer(); + await pump( + tester, + runSweep: () { + runs++; + return gate.future; + }, + ); + + final button = find.text('Clear Stale History Now'); + await tester.tap(button, warnIfMissed: false); + await tester.tap(button, warnIfMissed: false); + + expect(runs, 1, reason: 'the second tap in the same frame must be ignored'); + + gate.complete(outcome()); + await tester.pumpAndSettle(); + }); + + testWidgets('the button is disabled while it runs', (tester) async { + final gate = Completer(); + await pump(tester, runSweep: () => gate.future); + + await tester.tap(find.text('Clear Stale History Now')); + await tester.pump(); + + expect( + tester.widget(find.byType(FilledButton)).onPressed, + isNull, + reason: 'a second tap mid-sweep would run two VACUUMs at once', + ); + expect(find.text('Clearing...'), findsOneWidget); + + gate.complete(outcome(cleared: const ['a'])); + await tester.pumpAndSettle(); + + expect( + tester.widget(find.byType(FilledButton)).onPressed, + isNotNull, + reason: 'and it must come back, or the action works exactly once', + ); + }); + + testWidgets('an unreadable size leaves the row out rather than erroring', ( + tester, + ) async { + await pump( + tester, + runSweep: () async => outcome(), + readSize: () async => throw StateError('no size'), + ); + + expect(find.textContaining('Message database:'), findsNothing); + // The action is still usable: a size we cannot read is not a reason to + // block clearing. + expect( + tester.widget(find.byType(FilledButton)).onPressed, + isNotNull, + ); + }); +} diff --git a/untranslated.json b/untranslated.json index 7f449ec0..873a1bcb 100644 --- a/untranslated.json +++ b/untranslated.json @@ -168,6 +168,8 @@ "block_settingsTitle", "block_settingsSubtitle", "block_none", + "block_noRadio", + "block_noRadioHint", "block_keysSection", "block_namesSection", "block_namesHint", @@ -262,7 +264,16 @@ "setRegionScope_save", "setRegionScope_searchRepeaters", "setRegionScope_pathNote", - "setRegionScope_noPath" + "setRegionScope_noPath", + "storage_title", + "storage_databaseSize", + "storage_staleHint", + "storage_clearStaleNow", + "storage_working", + "storage_resultNothing", + "storage_resultCleared", + "storage_resultRefused", + "storage_resultFailed" ], "de": [ @@ -434,6 +445,8 @@ "block_settingsTitle", "block_settingsSubtitle", "block_none", + "block_noRadio", + "block_noRadioHint", "block_keysSection", "block_namesSection", "block_namesHint", @@ -528,7 +541,16 @@ "setRegionScope_save", "setRegionScope_searchRepeaters", "setRegionScope_pathNote", - "setRegionScope_noPath" + "setRegionScope_noPath", + "storage_title", + "storage_databaseSize", + "storage_staleHint", + "storage_clearStaleNow", + "storage_working", + "storage_resultNothing", + "storage_resultCleared", + "storage_resultRefused", + "storage_resultFailed" ], "es": [ @@ -700,6 +722,8 @@ "block_settingsTitle", "block_settingsSubtitle", "block_none", + "block_noRadio", + "block_noRadioHint", "block_keysSection", "block_namesSection", "block_namesHint", @@ -794,7 +818,16 @@ "setRegionScope_save", "setRegionScope_searchRepeaters", "setRegionScope_pathNote", - "setRegionScope_noPath" + "setRegionScope_noPath", + "storage_title", + "storage_databaseSize", + "storage_staleHint", + "storage_clearStaleNow", + "storage_working", + "storage_resultNothing", + "storage_resultCleared", + "storage_resultRefused", + "storage_resultFailed" ], "fr": [ @@ -966,6 +999,8 @@ "block_settingsTitle", "block_settingsSubtitle", "block_none", + "block_noRadio", + "block_noRadioHint", "block_keysSection", "block_namesSection", "block_namesHint", @@ -1060,7 +1095,16 @@ "setRegionScope_save", "setRegionScope_searchRepeaters", "setRegionScope_pathNote", - "setRegionScope_noPath" + "setRegionScope_noPath", + "storage_title", + "storage_databaseSize", + "storage_staleHint", + "storage_clearStaleNow", + "storage_working", + "storage_resultNothing", + "storage_resultCleared", + "storage_resultRefused", + "storage_resultFailed" ], "hu": [ @@ -1232,6 +1276,8 @@ "block_settingsTitle", "block_settingsSubtitle", "block_none", + "block_noRadio", + "block_noRadioHint", "block_keysSection", "block_namesSection", "block_namesHint", @@ -1326,7 +1372,16 @@ "setRegionScope_save", "setRegionScope_searchRepeaters", "setRegionScope_pathNote", - "setRegionScope_noPath" + "setRegionScope_noPath", + "storage_title", + "storage_databaseSize", + "storage_staleHint", + "storage_clearStaleNow", + "storage_working", + "storage_resultNothing", + "storage_resultCleared", + "storage_resultRefused", + "storage_resultFailed" ], "it": [ @@ -1498,6 +1553,8 @@ "block_settingsTitle", "block_settingsSubtitle", "block_none", + "block_noRadio", + "block_noRadioHint", "block_keysSection", "block_namesSection", "block_namesHint", @@ -1592,7 +1649,16 @@ "setRegionScope_save", "setRegionScope_searchRepeaters", "setRegionScope_pathNote", - "setRegionScope_noPath" + "setRegionScope_noPath", + "storage_title", + "storage_databaseSize", + "storage_staleHint", + "storage_clearStaleNow", + "storage_working", + "storage_resultNothing", + "storage_resultCleared", + "storage_resultRefused", + "storage_resultFailed" ], "ja": [ @@ -1764,6 +1830,8 @@ "block_settingsTitle", "block_settingsSubtitle", "block_none", + "block_noRadio", + "block_noRadioHint", "block_keysSection", "block_namesSection", "block_namesHint", @@ -1858,7 +1926,16 @@ "setRegionScope_save", "setRegionScope_searchRepeaters", "setRegionScope_pathNote", - "setRegionScope_noPath" + "setRegionScope_noPath", + "storage_title", + "storage_databaseSize", + "storage_staleHint", + "storage_clearStaleNow", + "storage_working", + "storage_resultNothing", + "storage_resultCleared", + "storage_resultRefused", + "storage_resultFailed" ], "ko": [ @@ -2030,6 +2107,8 @@ "block_settingsTitle", "block_settingsSubtitle", "block_none", + "block_noRadio", + "block_noRadioHint", "block_keysSection", "block_namesSection", "block_namesHint", @@ -2124,7 +2203,16 @@ "setRegionScope_save", "setRegionScope_searchRepeaters", "setRegionScope_pathNote", - "setRegionScope_noPath" + "setRegionScope_noPath", + "storage_title", + "storage_databaseSize", + "storage_staleHint", + "storage_clearStaleNow", + "storage_working", + "storage_resultNothing", + "storage_resultCleared", + "storage_resultRefused", + "storage_resultFailed" ], "nl": [ @@ -2296,6 +2384,8 @@ "block_settingsTitle", "block_settingsSubtitle", "block_none", + "block_noRadio", + "block_noRadioHint", "block_keysSection", "block_namesSection", "block_namesHint", @@ -2390,7 +2480,16 @@ "setRegionScope_save", "setRegionScope_searchRepeaters", "setRegionScope_pathNote", - "setRegionScope_noPath" + "setRegionScope_noPath", + "storage_title", + "storage_databaseSize", + "storage_staleHint", + "storage_clearStaleNow", + "storage_working", + "storage_resultNothing", + "storage_resultCleared", + "storage_resultRefused", + "storage_resultFailed" ], "pl": [ @@ -2562,6 +2661,8 @@ "block_settingsTitle", "block_settingsSubtitle", "block_none", + "block_noRadio", + "block_noRadioHint", "block_keysSection", "block_namesSection", "block_namesHint", @@ -2656,7 +2757,16 @@ "setRegionScope_save", "setRegionScope_searchRepeaters", "setRegionScope_pathNote", - "setRegionScope_noPath" + "setRegionScope_noPath", + "storage_title", + "storage_databaseSize", + "storage_staleHint", + "storage_clearStaleNow", + "storage_working", + "storage_resultNothing", + "storage_resultCleared", + "storage_resultRefused", + "storage_resultFailed" ], "pt": [ @@ -2828,6 +2938,8 @@ "block_settingsTitle", "block_settingsSubtitle", "block_none", + "block_noRadio", + "block_noRadioHint", "block_keysSection", "block_namesSection", "block_namesHint", @@ -2922,7 +3034,16 @@ "setRegionScope_save", "setRegionScope_searchRepeaters", "setRegionScope_pathNote", - "setRegionScope_noPath" + "setRegionScope_noPath", + "storage_title", + "storage_databaseSize", + "storage_staleHint", + "storage_clearStaleNow", + "storage_working", + "storage_resultNothing", + "storage_resultCleared", + "storage_resultRefused", + "storage_resultFailed" ], "ru": [ @@ -3094,6 +3215,8 @@ "block_settingsTitle", "block_settingsSubtitle", "block_none", + "block_noRadio", + "block_noRadioHint", "block_keysSection", "block_namesSection", "block_namesHint", @@ -3188,7 +3311,16 @@ "setRegionScope_save", "setRegionScope_searchRepeaters", "setRegionScope_pathNote", - "setRegionScope_noPath" + "setRegionScope_noPath", + "storage_title", + "storage_databaseSize", + "storage_staleHint", + "storage_clearStaleNow", + "storage_working", + "storage_resultNothing", + "storage_resultCleared", + "storage_resultRefused", + "storage_resultFailed" ], "sk": [ @@ -3360,6 +3492,8 @@ "block_settingsTitle", "block_settingsSubtitle", "block_none", + "block_noRadio", + "block_noRadioHint", "block_keysSection", "block_namesSection", "block_namesHint", @@ -3454,7 +3588,16 @@ "setRegionScope_save", "setRegionScope_searchRepeaters", "setRegionScope_pathNote", - "setRegionScope_noPath" + "setRegionScope_noPath", + "storage_title", + "storage_databaseSize", + "storage_staleHint", + "storage_clearStaleNow", + "storage_working", + "storage_resultNothing", + "storage_resultCleared", + "storage_resultRefused", + "storage_resultFailed" ], "sl": [ @@ -3626,6 +3769,8 @@ "block_settingsTitle", "block_settingsSubtitle", "block_none", + "block_noRadio", + "block_noRadioHint", "block_keysSection", "block_namesSection", "block_namesHint", @@ -3720,7 +3865,16 @@ "setRegionScope_save", "setRegionScope_searchRepeaters", "setRegionScope_pathNote", - "setRegionScope_noPath" + "setRegionScope_noPath", + "storage_title", + "storage_databaseSize", + "storage_staleHint", + "storage_clearStaleNow", + "storage_working", + "storage_resultNothing", + "storage_resultCleared", + "storage_resultRefused", + "storage_resultFailed" ], "sv": [ @@ -3892,6 +4046,8 @@ "block_settingsTitle", "block_settingsSubtitle", "block_none", + "block_noRadio", + "block_noRadioHint", "block_keysSection", "block_namesSection", "block_namesHint", @@ -3986,7 +4142,16 @@ "setRegionScope_save", "setRegionScope_searchRepeaters", "setRegionScope_pathNote", - "setRegionScope_noPath" + "setRegionScope_noPath", + "storage_title", + "storage_databaseSize", + "storage_staleHint", + "storage_clearStaleNow", + "storage_working", + "storage_resultNothing", + "storage_resultCleared", + "storage_resultRefused", + "storage_resultFailed" ], "uk": [ @@ -4158,6 +4323,8 @@ "block_settingsTitle", "block_settingsSubtitle", "block_none", + "block_noRadio", + "block_noRadioHint", "block_keysSection", "block_namesSection", "block_namesHint", @@ -4252,7 +4419,16 @@ "setRegionScope_save", "setRegionScope_searchRepeaters", "setRegionScope_pathNote", - "setRegionScope_noPath" + "setRegionScope_noPath", + "storage_title", + "storage_databaseSize", + "storage_staleHint", + "storage_clearStaleNow", + "storage_working", + "storage_resultNothing", + "storage_resultCleared", + "storage_resultRefused", + "storage_resultFailed" ], "zh": [ @@ -4424,6 +4600,8 @@ "block_settingsTitle", "block_settingsSubtitle", "block_none", + "block_noRadio", + "block_noRadioHint", "block_keysSection", "block_namesSection", "block_namesHint", @@ -4518,6 +4696,15 @@ "setRegionScope_save", "setRegionScope_searchRepeaters", "setRegionScope_pathNote", - "setRegionScope_noPath" + "setRegionScope_noPath", + "storage_title", + "storage_databaseSize", + "storage_staleHint", + "storage_clearStaleNow", + "storage_working", + "storage_resultNothing", + "storage_resultCleared", + "storage_resultRefused", + "storage_resultFailed" ] }