Passively capture, archive, and hoard your web browsing history, including the contents of the pages you visit, for later offline viewing, mirroring, and/or indexing. Your own personal private Wayback Machine that can also archive HTTP POST requests and responses, as well as most other HTTP-level data.
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1" />
<title>Hoardy-Web: Settings</title>
<link rel="shortcut icon" type="$iconMIME$" href="../icon/$iconFile$">
<link rel="stylesheet" href="main.css?v=$version$">
<style>
@layer defaults {
body {
border: 3px solid var(--outline-color);
box-sizing: border-box;
margin: 0;
max-width: 455px; /* NB: keep in sync with values in ./help.template */
min-width: 300px;
padding: 5px;
}
#body {
font-size: 14px;
line-height: 160%;
}
input[type="button"], .help-btn {
vertical-align: top;
}
.help-tip {
left: 10%;
right: 10%;
}
h1 {
font-size: 110%;
margin: 0;
display: flex;
}
h2 {
font-size: 105%;
margin: 0;
display: flex;
}
h3 {
font-size: 102%;
margin: 0;
display: flex;
}
h4 {
font-size: 100%;
margin: 0;
display: flex;
}
h1 code,
h2 code,
h3 code,
h4 code {
margin: auto 0.5ch;
}
h1 span.right,
h2 span.right,
h3 span.right,
h4 span.right {
display: flex;
}
h1 input[type="button"],
h2 input[type="button"],
h3 input[type="button"],
h4 input[type="button"] {
margin-left: 0.5em;
}
#version {
vertical-align: top;
}
.indent, .idots, .isubdots, .ishiftdots {
padding-left: 10px;
}
.idots {
border-left: 4px dotted var(--separator-color);
margin-left: 3px;
}
.isubdots {
border-left: 2px dotted var(--separator-color);
margin-left: 3px;
}
.ishiftdots {
border-left: 2px dotted var(--separator-color);
margin-left: 12px;
}
.stats .help-root > div {
display: flex;
}
.stats .help-root > div > span:nth-child(2) {
padding-left: 1em;
margin: 0 1em 0 auto;
}
.stats .help-root > div > span:nth-child(3) {
min-width: 10em;
text-align: right;
}
div.target {
padding: 0.5em;
}
span.target,
input.target {
display: inline-block;
padding: 1em;
}
#showAll {
width: 99%;
margin: 5px auto 0 auto;
}
}
@layer overrides {
.hidden {
display: none;
}
.off, .off * {
--box-shadow-color: var(--text-inactive-background);
--button-background: var(--text-inactive-background);
--button-color: var(--text-inactive-color);
--code-background: var(--text-inactive-background);
--hover-background: var(--text-inactive-color);
--hover-color: var(--text-inactive-background);
--input-border-color: var(--text-inactive-color);
--input-color: var(--text-inactive-color);
--separator-color: var(--text-inactive-color);
--text-background: var(--text-inactive-background);
--text-color: var(--text-inactive-color);
--text-shadow-color: var(--text-inactive-background);
--toggle-background-bad: var(--text-inactive-background);
--toggle-background-good: var(--text-inactive-background);
--toggle-background: var(--text-inactive-background);
--toggle-border-color-bad: var(--text-inactive-color);
--toggle-border-color-good: var(--text-inactive-color);
--toggle-border-color: var(--text-inactive-color);
--toggle-border-color: var(--text-inactive-color);
--toggle-dot-background: var(--text-inactive-background);
--untoggle-background-bad: var(--text-inactive-background);
--untoggle-background-good: var(--text-inactive-background);
--untoggle-background: var(--text-inactive-background);
--untoggle-border-color-bad: var(--text-inactive-color);
--untoggle-border-color-good: var(--text-inactive-color);
--untoggle-border-color: var(--text-inactive-color);
--untoggle-dot-background: var(--text-inactive-background);
}
section {
background: var(--text-background);
border-radius: 3px;
}
}
</style>
</head>
<body>
<div id="body_loading"></div>
<div id="body_error" style="display: none"></div>
<div id="body" style="display: none">
<!-- idBody -->
<h1>
Hoardy-Web
<input type="button" id="version" data-help="Open the `Changelog` page." value="v?" />
<span id="div-reloadSelf" class="on-reload">
<input type="button" id="reloadSelf" data-help="Reload and update `Hoardy-Web`. That is, ask `Hoardy-Web` to perform the following: wait for all in-flight reqres to finish, stash everything not yet stashed into local storage (regardless of `Stash 'collected' reqres into local storage` and `Stash 'in_limbo' reqres` options), run all scheduled actions immediately, dump the recent history log and per-tab configs into local storage, and then, if all of the above succeed, ask the browser to reload `Hoardy-Web`. If the browser has a new version of `Hoardy-Web` fetched and ready to go (which it has if this button appears to be highlighted), pressing this button will make the browser unload this and then load the new version of `Hoardy-Web`, thus updating it without a browser restart. This feature is experimental at the moment. See also `Auto-reload on updates` option below." value="Reload" />
</span>
<span class="on-pending">
<input type="button" id="cancelReloadSelf" data-help="Cancel pending `Hoardy-Web` reload." value="Reload pending..." />
</span>
<span class="right">
<input type="button" id="help" data-help="Open the `Help` page." value="Help" />
</span>
</h1>
<div class="idots">
<div class="stats">
<div id="div-stats.actions" data-help="The numbers of currently running and scheduled internal actions. Internal actions are things like: delayed saving of config and persistent stats, delayed exports via `saveAs`, automatic retries of failed archivals, actions generated by `Automatic actions for recently closed tabs` below, etc. The point of this stat being displayed is that if one of these numbers is non-zero, then you probably should wait for those actions to finish before closing your browser. Otherwise, you might lose some data. When the first number is non-zero, toolbar button's badge has `^` in it. When the second number is non-zero, toolbar button's badge has `~` or `.` in it (depending on task priority).">
<span>Actions</span>
<span>
<input type="button" id="runActions" data-help="For scheduled actions that can be run immediately, run all of them." value="Run" />
<input type="button" id="cancelActions" data-help="For scheduled actions that can be canceled, cancel all of them." value="Cancel" />
</span>
<span>
<span id="stats.running">0</span>
+
<span id="stats.scheduled">0</span>
</span>
</div>
<div class="isubdots">
<div id="div-stats.running_actions" class="more" data-help="Names of the currently running internal actions.">
<span>... running</span>
<span>
</span>
<span>
<span id="stats.running_actions"></span>
</span>
</div>
<div id="div-stats.scheduled_actions" class="more" data-help="Names of the currently scheduled internal actions.">
<span>... scheduled</span>
<span>
</span>
<span>
<span id="stats.scheduled_actions"></span>
</span>
</div>
</div>
</div>
</div>
<section id="global-options">
<h2>
Globally
<span class="right">
<input type="button" id="snapshotAll" data-shortcut="snapshotAll" data-help="Take DOM snapshots of all frames of all open tabs for which `Include in global snapshots` setting is enabled." value="Snapshot" />
<input type="button" id="forgetHistory" data-help="Forget recent history." value="Forget" />
<input type="button" id="showState" data-shortcut="showState" data-help="Show the internal state and reqres history logs." value="State" />
</span>
</h2>
<div class="idots">
<!-- globalOptions -->
<div class="stats">
<div id="div-stats.queued_failed" data-help="At the moment, the number of reqres that are waiting to be archived in the archival queue (and the sum total of all sizes of their dumps). / At the moment, the number of reqres that failed to be archived via one or more of the selected archiving methods and/or failed to be stashed to local storage (and the sum total of all sizes of their dumps).">
<span>Queued/Failed</span>
<span>
<input type="button" id="retryFailed" data-help="Retry archiving of all reqres that failed to be archived via one or more selected archiving methods. Then, retry stashing of all reqres that failed to be stashed to local storage." value="Retry" />
</span>
<span>
<span id="stats.queued">0</span>
(<span id="stats.queued_size">0</span>)
/
<span id="stats.failed">0</span>
(<span id="stats.failed_size">0</span>)
</span>
</div>
<div id="div-stats.collected" data-help="From the last reset, the number of `finished` reqres that were taken for archival (and the sum total of all sizes of their dumps).">
<span>Collected</span>
<span>
</span>
<span>
<span id="stats.collected">0</span>
(<span id="stats.collected_size">0</span>)
</span>
</div>
<div id="div-stats.discarded" data-help="From the last reset, the number of `finished` reqres that were NOT taken for archival and thus discarded from memory (and the sum total of all sizes of their dumps).">
<span>Discarded</span>
<span>
</span>
<span>
<span id="stats.discarded">0</span>
(<span id="stats.discarded_size">0</span>)
</span>
</div>
<div id="div-stats.in_limbo" data-help="At the moment, the number of `finished` reqres that are in `in_limbo` state (and the sum total of all sizes of their dumps).">
<span>In limbo</span>
<span>
<input type="button" id="collectAllInLimbo" data-shortcut="collectAllInLimbo" data-help="Collect all reqres in `in_limbo` state." value="Collect" />
<input type="button" id="discardAllInLimbo" data-shortcut="discardAllInLimbo" data-help="Discard all reqres in `in_limbo` state." value="Discard" />
</span>
<span>
<span id="stats.in_limbo">0</span>
(<span id="stats.in_limbo_size">0</span>)
</span>
</div>
<div id="div-stats.picked" class="more" data-help="From the last reset, the number of reqres that satisfied `Pick reqres for archival when they finish` conditions at the moment they `finished`.">
<span>Picked</span>
<span>
</span>
<span>
<span id="stats.picked">0</span>
</span>
</div>
<div id="div-stats.dropped" class="more" data-help="From the last reset, the number of reqres that did NOT satisfy `Pick reqres for archival when they finish` conditions at the moment they `finished`.">
<span>Dropped</span>
<span>
</span>
<span>
<span id="stats.dropped">0</span>
</span>
</div>
<div id="div-stats.problematic" data-help="At the moment, the number of reqres that satisfied `Mark reqres as 'problematic' when they finish` conditions at the moment they `finished`.">
<span>Problematic</span>
<span>
<input type="button" id="unmarkAllProblematic" data-shortcut="unmarkAllProblematic" data-help="Unmark all `problematic` reqres." value="Unmark" />
</span>
<span>
<span id="stats.problematic">0</span>
</span>
</div>
<div id="div-stats.in_flight" data-help="At the moment, the number of reqres that have not finished yet. See the `Help` page for more info.">
<span>In flight</span>
<span>
<input type="button" id="stopAllInFlight" data-help="Stop tracking progress of all in-flight reqres and either pick or drop them, depending on their completion and `Pick reqres for archival when they finish` options." value="Stop" />
</span>
<span>
<span id="stats.in_flight">0</span>
+
<span id="stats.finishing_up">0</span>
</span>
</div>
</div>
<div class="more">
<ui id="config.workOfflineImpure" type="boolean" data-help="When toggling any of the `Work offline` options on this page or via keyboard shortcuts, automatically set the corresponding `Track new requests` option to the opposite value. Disabled by default to minimize surprises. Even with this option enabled you can still toggle `Track new requests` manually. See the `Help` page for more info.">Toggle <code>Work offline</code> options impurely</ui>
<ui id="config.workOffline" type="boolean" class="prefer-off" data-help="Start canceling all new networking requests generated by this browser. Enabling this does essentially the same thing as `File > Work Offline` setting of Firefox-based browsers, except this implementation supports logging. See also the many `Work offline` options below. See the `Help` page for more info.">Work offline</ui>
<ui id="config.collecting" type="boolean" class="prefer-on" data-help="Also known as `Enable this extension/add-on`. Generate a new reqres and start tracking its progress when the browser makes a new `HTTP` request. Disabling this option will stop `Hoardy-Web` from recording any new data. Already tracked reqres will still get tracked until they finish.">Track new requests</ui>
</div>
<section id="problematic-options" class="more">
<h3>Mark reqres as <code>problematic</code> when they finish</h3>
<div class="isubdots">
<!-- problematicOptions -->
<ui id="config.markProblematicPartialRequest" type="boolean" class="c" data-help="Marke a newly `finished` reqres as `problematic` when its request body is incomplete. Enabled by default. See the "Quirks and Bugs" section of the `Help` page for details.">... {} with partial POST form data</ui>
<ui id="config.markProblematicCanceled" type="boolean" class="prefer-off c" data-help="Mark a newly `finished` reqres as `problematic` when it was canceled before it was even sent (this usually means the `HTTP` request in question was blocked by another extension like `uBlock Origin`). Disabled by default.">... {} in <code>canceled</code> state</ui>
<ui id="config.markProblematicNoResponse" type="boolean" class="prefer-on c" data-help="Mark a newly `finished` reqres as `problematic` when it got no response (i.e. the request in question was interrupted before request headers were received; this usually means a networking issue). Enabled by default.">... {} in <code>no_response</code> state</ui>
<ui id="config.markProblematicIncomplete" type="boolean" class="prefer-on c" data-help="Mark a newly `finished` reqres as `problematic` when its response body is incomplete (e.g. response body was interrupted in the middle by a networking issue). Enabled by default.">... {} in <code>incomplete</code> state</ui>
<ui id="config.markProblematicIncompleteFC" type="boolean" class="prefer-off c" data-help="Mark a newly `finished` reqres as `problematic` when it was loaded from browser's cache but its response data was not given to the extension (this only happens on Firefox-based browsers). Disabled by default because this usually means that one of the previously `collected` reqres had this response data archived already, if had not, you can reload the page with browser's cache disabled via `Contrlol+F5`.">... {} in <code>incomplete_fc</code> state</ui>
<ui id="config.markProblematicTransientCodes" type="boolean" class="prefer-on c" data-help="Mark a newly `finished` reqres as `problematic` when its `HTTP` response status code is a transient error. Enabled by default because this usually means that, to be properly archived, the page needs to be reloaded later.">... {} with transient server errors</ui>
<ui id="config.markProblematicPermanentCodes" type="boolean" class="c" data-help="Mark a newly `finished` reqres as `problematic` when its `HTTP` response status code is a permanent error. Disabled by default because this usually means that reloading the page won't help.">... {} with permanent server errors</ui>
<ui id="config.markProblematicWithImportantErrors" type="boolean" class="prefer-on c" data-help="Mark a newly `finished` reqres as `problematic` when it had important collection errors. Currently, only errors generated by `Hoardy-Web` itself (when it failed to collect the data from the browser for various reasons), are considered important. Enabled by default.">... {} with important reqres errors</ui>
<ui id="config.markProblematicPickedWithErrors" type="boolean" class="prefer-on c" data-help="Mark a newly `finished` reqres as `problematic` when `Hoardy-Web` encountered (non-trivial) errors while collecting it and `Pick reqres for archival when they finish` settings picked it for archival. Enabled by default.">... {} with reqres errors and get <code>picked</code></ui>
<ui id="config.markProblematicDroppedWithErrors" type="boolean" class="c" data-help="Mark a newly `finished` reqres as `problematic` when `Hoardy-Web` encountered (non-trivial) errors while collecting it and `Pick reqres for archival when they finish` settings did NOT pick it for archival. Disabled by default because with this enabled all reqres blocked by ad-blocking extension like `uBlock Origin` will be marked as `problematic`.">... {} with reqres errors and get <code>dropped</code></ui>
<!-- problematicOptions -->
</div>
</section>
<section id="pick-options" class="more">
<h3>Pick reqres for archival when they finish</h3>
<div class="isubdots">
<!-- pickOptions -->
<ui id="config.archivePartialRequest" type="boolean" class="prefer-on c" data-help="Pick a newly `finished` reqres for archival even when its request body is incomplete. Enabled by default, and you probably want to keep this enabled. See the "Quirks and Bugs" section of the `Help` page for details.">... {} with partial POST form data</ui>
<ui id="config.archiveCanceled" type="boolean" class="prefer-off c" data-help="Pick a newly `finished` reqres for archival even when it was canceled before it was even sent (this usually means the `HTTP` request in question was blocked by another extension like `uBlock Origin`). Disabled by default because such archived reqres carry no information except that the browser tried to do a request at specified time.">... {} in <code>canceled</code> state</ui>
<ui id="config.archiveNoResponse" type="boolean" class="prefer-off c" data-help="Pick a newly `finished` reqres for archival even when it got no response (i.e. the request in question was interrupted before request headers were received, this usually means a networking issue). Disabled by default because such archived reqres carry no information except that the browser tried to do a request at specified time.">... {} in <code>no_response</code> state</ui>
<ui id="config.archiveIncompleteResponse" type="boolean" class="prefer-off c" data-help="Pick a newly `finished` reqres for archival even when its response body is incomplete (e.g. response body was interrupted in the middle by a networking issue). Disabled by default because simply reloading the page and not dealing with partial files is usually a better option.">... {} in <code>incomplete</code> or <code>incomplete_fc</code> state</ui>
<ui id="config.archive1xxCodes" type="boolean" class="prefer-on c" data-help="Pick a newly `finished` reqres for archival even when its `HTTP` response status code is `1xx`. Enabled by default.">... {} with <code>1xx</code> status codes</ui>
<ui id="config.archive3xxCodes" type="boolean" class="prefer-on c" data-help="Pick a newly `finished` reqres for archival even when its `HTTP` response status code is `3xx`. Enabled by default.">... {} with <code>3xx</code> status codes</ui>
<ui id="config.archiveTransientCodes" type="boolean" class="prefer-on c" data-help="Pick a newly `finished` reqres for archival even when its `HTTP` response status code is a transient error. Enabled by default.">... {} with transient server errors</ui>
<ui id="config.archivePermanentCodes" type="boolean" class="prefer-on c" data-help="Pick a newly `finished` reqres for archival even when its `HTTP` response status code is a permanent error. Enabled by default.">... {} with permanent server errors</ui>
<ui id="config.archiveWithErrors" type="boolean" class="prefer-on c" data-help="Pick a newly `finished` reqres for archival even when `Hoardy-Web` encountered (non-trivial) errors while collecting it. Enabled by default because very few errors mean the data is invalid. E.g., network errors for requests aborted by other extensions, as well as parsing and rendering-related errors reported by the browser can usually be ignored.">... {} with reqres errors</ui>
<!-- pickOptions -->
</div>
</section>
<!-- globalOptions -->
</div>
</section>
<section id="extension-options" class="more">
<h2>Extensions</h2>
<div class="idots">
<!-- extensionOptions -->
<ui id="config.extension.workOffline" type="boolean" class="prefer-off" data-help="Start canceling all new networking requests originating from browser's extensions/add-ons. Enabling this does essentially the same thing as "Work offline" setting of Firefox-based browsers, except for requests generated by extensions only. See the `Help` page for more info.">Work offline</ui>
<section class="on-collecting">
<ui id="config.extension.collecting" type="boolean" data-help="Track new requests originating from browser extensions.">Track new requests</ui>
</section>
<section class="on-problematicNotify">
<ui id="config.extension.problematicNotify" type="boolean" data-help="Include `problematic` reqres originating from browser's extensions/add-ons in `Generate notifications about > ... new 'problematic' reqres` notifications. This only has an effect if the latter option is enabled.">Notify about <code>problematic</code> reqres</ui>
</section>
<ui id="config.extension.limbo" type="boolean" data-help="For reqres originating from browser's extensions/add-ons, put newly `finished` reqres tab that satisfy `Pick reqres for archival when they finish` settings into limbo until you collect them for archival or discard them manually.">Pick into limbo</ui>
<ui id="config.extension.negLimbo" type="boolean" class="prefer-off" data-help="For reqres originating from browser's extensions/add-ons, put newly `finished` reqres tab that do NOT satisfy `Pick reqres for archival when they finish` settings into limbo instead of discarding them immediately. Useful for debugging.">Drop into limbo</ui>
<section class="on-stash">
<ui id="config.extension.stashLimbo" type="boolean" data-help="For reqres originating from browser's extensions/add-ons, backup `in_limbo` reqres into browser's local storage. This option does nothing if `Stash 'collected' reqres into local storage` is disabled. Enabled by default. See the `Help` page for more info.">Stash <code>in_limbo</code> reqres</ui>
</section>
<ui id="config.extension.bucket" type="string" data-help="Use this bucket when archiving reqres originating from browser extensions.">Bucket</ui>
<!-- extensionOptions -->
</div>
</section>
<section id="background-options" class="more">
<h2>Background tasks</h2>
<div class="idots">
<!-- backgroundOptions -->
<ui id="config.background.workOffline" type="boolean" class="prefer-off" data-help="Start canceling all new networking requests originating from browser's background tasks (excluding those originating from extensions). Enabling this does essentially the same thing as "Work offline" setting of Firefox-based browsers, except for requests generated by backgrounds tasks only. See the `Help` page for more info.">Work offline</ui>
<section class="on-collecting">
<ui id="config.background.collecting" type="boolean" class="prefer-on" data-help="Track new requests originating from browser's background tasks (excluding those originating from extensions). With the default browser config you probably should not disable this as browsers do link pre-fetching in background, and disabling this will miss that data.">Track new requests</ui>
</section>
<section class="on-problematicNotify">
<ui id="config.background.problematicNotify" type="boolean" data-help="Include `problematic` reqres originating from browser's background tasks (excluding those originating from extensions) in `Generate notifications about > ... new 'problematic' reqres` notifications. This only has an effect if the latter option is enabled.">Notify about <code>problematic</code> reqres</ui>
</section>
<ui id="config.background.limbo" type="boolean" data-help="For reqres originating from browser's background tasks (excluding those originating from extensions), put newly `finished` reqres tab that satisfy `Pick reqres for archival when they finish` settings into limbo until you collect them for archival or discard them manually.">Pick into limbo</ui>
<ui id="config.background.negLimbo" type="boolean" class="prefer-off" data-help="For reqres originating from browser's background tasks (excluding those originating from extensions), put newly `finished` reqres tab that do NOT satisfy `Pick reqres for archival when they finish` settings into limbo instead of discarding them immediately. Useful for debugging.">Drop into limbo</ui>
<section class="on-stash">
<ui id="config.background.stashLimbo" type="boolean" data-help="For reqres originating from browser's background tasks (excluding those originating from extensions), backup `in_limbo` reqres into browser's local storage. This option does nothing if `Stash 'collected' reqres into local storage` is disabled. Enabled by default. See the `Help` page for more info.">Stash <code>in_limbo</code> reqres</ui>
</section>
<ui id="config.background.bucket" type="string" data-help="Use this bucket when archiving reqres originating from browser's background tasks (excluding those originating from extensions).">Bucket</ui>
<!-- backgroundOptions -->
</div>
</section>
<section id="root-tab-options" class="more">
<h2>New root tabs</h2>
<div class="idots">
<!-- rootTabOptions -->
<ui id="config.root.snapshottable" type="boolean" class="prefer-on" data-help="Enable `Include in global snapshots` options in new tabs opened via browser's "New Tab" action (new tabs created via the plus sign in the tab bar, `Control+T`, `New Tab` menu item).">Set <code>Include in global snapshots</code></ui>
<ui id="config.root.workOffline" type="boolean" class="prefer-off" data-help="Enable `Work offline` options in new tabs opened via browser's "New Tab" action (new tabs created via the plus sign in the tab bar, `Control+T`, `New Tab` menu item). See the `Help` page for more info.">Set <code>Work offline</code></ui>
<section class="on-collecting">
<ui id="config.root.collecting" type="boolean" class="prefer-on" data-help="Enable `Track new requests` option in new tabs opened via browser's "New Tab" browser action (new tabs created via the plus sign in the tab bar, `Control+T`, `New Tab` menu item).">Set <code>Track new requests</code></ui>
</section>
<section class="on-problematicNotify">
<ui id="config.root.problematicNotify" type="boolean" data-help="Enable `Notify about 'problematic' reqres` in new tabs opened via browser's "New Tab" action (new tabs created via the plus sign in the tab bar, `Control+T`, `New Tab` menu item).">Set <code>Notify about 'problematic' reqres</code></ui>
</section>
<ui id="config.root.limbo" type="boolean" data-help="Enable `Pick into limbo` option in new tabs opened via browser's "New Tab" action (new tabs created via the plus sign in the tab bar, `Control+T`, `New Tab` menu item).">Set <code>Pick into limbo</code></ui>
<ui id="config.root.negLimbo" type="boolean" class="prefer-off" data-help="Enable `Drop into limbo` option in new tabs opened via browser's "New Tab" action (new tabs created via the plus sign in the tab bar, `Control+T`, `New Tab` menu item).">Set <code>Drop into limbo</code></ui>
<section class="on-stash">
<ui id="config.root.stashLimbo" type="boolean" data-help="Enable `Stash 'in_limbo' reqres` option in in new tabs opened via browser's "New Tab" action (new tabs created via the plus sign in the tab bar, `Control+T`, `New Tab` menu item).">Set <code>Stash 'in_limbo' reqres</code></ui>
</section>
<ui id="config.root.bucket" type="string" data-help="Use this bucket when archiving reqres originating from new tabs opened via browser's "New Tab" browser action (new tabs created via the plus sign in the tab bar, `Control+T`, `New Tab` menu item).">Bucket</ui>
<!-- rootTabOptions -->
</div>
</section>
<section id="this-tab-options">
<h2>This tab
<span class="right">
<input type="button" id="snapshotTab" data-shortcut="snapshotTab" data-help="Take DOM snapshots of all frames of this tab, regardless of `Track newly generated requests` setting." value="Snapshot" />
<input type="button" id="forgetTabHistory" data-help="For reqres of this tab, forget recent history." value="Forget" />
<input type="button" id="showTabState" data-shortcut="showTabState" data-help="For reqres of this tab, show the internal state and reqres history logs." value="State" />
</span>
</h2>
<div class="idots">
<!-- thisTabOptions -->
<div class="stats">
<div id="div-tabstats.collected" class="more" data-help="For this tab, the number of `finished` reqres that were taken for archival (and the sum total of all sizes of their dumps).">
<span>Collected</span>
<span>
</span>
<span>
<span id="tabstats.collected">0</span>
(<span id="tabstats.collected_size">0</span>)
</span>
</div>
<div id="div-tabstats.discarded" class="more" data-help="For this tab, the number of `finished` reqres that were NOT taken for archival and thus were discarded from memory (and the sum total of all sizes of their dumps).">
<span>Discarded</span>
<span>
</span>
<span>
<span id="tabstats.discarded">0</span>
(<span id="tabstats.discarded_size">0</span>)
</span>
</div>
<div id="div-tabstats.in_limbo" data-help="For this tab, the number of `finished` reqres that are in `in_limbo` state (and the sum total of all sizes of their dumps).">
<span>In limbo</span>
<span>
<input type="button" id="collectAllTabInLimbo" data-shortcut="collectAllTabInLimbo" data-help="For reqres of this tab, collect all reqres in `in_limbo` state." value="Collect" />
<input type="button" id="discardAllTabInLimbo" data-shortcut="discardAllTabInLimbo" data-help="For reqres of this tab, discard all reqres in `in_limbo` state." value="Discard" />
</span>
<span>
<span id="tabstats.in_limbo">0</span>
(<span id="tabstats.in_limbo_size">0</span>)
</span>
</div>
<div id="div-tabstats.picked" class="more" data-help="For this tab, the number of reqres that satisfied `Pick reqres for archival when they finish` conditions at the moment they `finished`.">
<span>Picked</span>
<span>
</span>
<span>
<span id="tabstats.picked">0</span>
</span>
</div>
<div id="div-tabstats.dropped" class="more" data-help="For this tab, the number of reqres that did NOT satisfy `Pick reqres for archival when they finish` conditions at the moment they `finished`.">
<span>Dropped</span>
<span>
</span>
<span>
<span id="tabstats.dropped">0</span>
</span>
</div>
<div id="div-tabstats.problematic" data-help="For this tab, the number of reqres that satisfied `Mark reqres as 'problematic' when they finish` conditions at the moment they `finished`.">
<span>Problematic</span>
<span>
<input type="button" id="unmarkAllTabProblematic" data-shortcut="unmarkAllTabProblematic" data-help="For reqres of this tab, unmark all `problematic` reqres." value="Unmark" />
</span>
<span>
<span id="tabstats.problematic">0</span>
</span>
</div>
<div id="div-tabstats.in_flight" data-help="For this tab, the number of in-flight reqres that have not `finished` yet. See the `Help` page for more info.">
<span>In flight</span>
<span>
<input type="button" id="stopTabInFlight" data-help="For reqres of this tab, stop tracking progress of all in-flight requests and either collect them for archival or fail them, depending on completion and `Pick reqres for archival when they finish` options." value="Stop" />
</span>
<span>
<span id="tabstats.in_flight">0</span>
+
<span id="tabstats.finishing_up">0</span>
</span>
</div>
</div>
<ui id="tabconfig.snapshottable" type="boolean" class="more prefer-on" data-help="Include this tab in a set of tabs that will be DOM-snapshotted by `Globally > Snapshot` button.">Include in global snapshots</ui>
<ui id="tabconfig.workOffline" type="boolean" class="prefer-off" data-shortcut="toggleTabConfigWorkOffline" data-help="Start canceling all new networking requests generated by this tab. Enabling this does essentially the same thing as "Work offline" setting of Firefox-based browsers, except for requests generated by this tab only. See the `Help` page for more info.">Work offline</ui>
<section class="on-collecting">
<ui id="tabconfig.collecting" type="boolean" class="prefer-on" tabindex=2 data-shortcut="toggleTabConfigTracking" data-help="Track new requests originating from this tab.">Track new requests</ui>
</section>
<section class="on-problematicNotify">
<ui id="tabconfig.problematicNotify" type="boolean" data-help="Include `problematic` reqres originating from this tab in `Generate notifications about > ... new 'problematic' reqres` notifications. This only has an effect if the latter option is enabled.">Notify about <code>problematic</code> reqres</ui>
</section>
<ui id="tabconfig.limbo" type="boolean" tabindex=3 data-shortcut="toggleTabConfigLimbo" data-help="For this tab, put newly `finished` reqres tab that satisfy `Pick reqres for archival when they finish` settings into limbo until you collect them for archival or discard them manually.">Pick into limbo</ui>
<ui id="tabconfig.negLimbo" type="boolean" class="more prefer-off" data-help="For this tab, put newly `finished` reqres that do NOT satisfy `Pick reqres for archival when they finish` settings into limbo instead of discarding them immediately. Useful for debugging.">Drop into limbo</ui>
<section class="on-stash">
<ui id="tabconfig.stashLimbo" type="boolean" class="more" data-help="For this tab, backup `in_limbo` reqres into browser's local storage. With this option enabled, `Hoardy-Web` will keep `in_limbo` reqres across browser restarts and extension reloads. This option does nothing if `Stash 'collected' reqres into local storage` is disabled. Enabled by default. See the `Help` page for more info.">Stash <code>in_limbo</code> reqres</ui>
</section>
<ui id="tabconfig.bucket" type="string" data-help="Use this bucket when archiving reqres originating from this tab.">Bucket</ui>
<!-- thisTabOptions -->
</div>
</section>
<section id="this-tab-children-options">
<h3>This tab's new children</h3>
<div class="idots">
<!-- thisTabChildrenOptions -->
<ui id="tabconfig.children.snapshottable" type="boolean" class="more prefer-on" data-help="Enable `Include in global snapshots` options in new tabs spawned from this tab (via middle mouse click, context menu actions).">Set <code>Include in global snapshots</code></ui>
<ui id="tabconfig.children.workOffline" type="boolean" class="prefer-off" data-help="Enable `Work offline` option in new tabs spawned from this tab (via middle mouse click, context menu actions). See the `Help` page for more info.">Set <code>Work offline</code></ui>
<section class="on-collecting">
<ui id="tabconfig.children.collecting" type="boolean" tabindex=4 class="prefer-on" data-shortcut="toggleTabConfigChildrenTracking" data-help="Enable `Track new requests` option in new tabs spawned from this tab (via middle mouse click, context menu actions).">Set <code>Track new requests</code></ui>
</section>
<section class="on-problematicNotify">
<ui id="tabconfig.children.problematicNotify" type="boolean" data-help="Enable `Notify about 'problematic' reqres` in new tabs spawned from this tab (via middle mouse click, context menu actions).">Set <code>Notify about 'problematic' reqres</code></ui>
</section>
<ui id="tabconfig.children.limbo" type="boolean" tabindex=5 data-shortcut="toggleTabConfigChildrenLimbo" data-help="Enable `Pick into limbo` option in new tabs spawned from this tab (via middle mouse click, context menu actions).">Set <code>Pick into limbo</code></ui>
<ui id="tabconfig.children.negLimbo" type="boolean" class="more prefer-off" data-help="Enable `Drop into limbo` option in new tabs spawned from this tab (via middle mouse click, context menu actions).">Set <code>Drop into limbo</code></ui>
<section class="on-stash">
<ui id="tabconfig.children.stashLimbo" type="boolean" class="more" data-help="Enable `Stash 'in_limbo' reqres` option in new tabs spawned from this tab (via middle mouse click, context menu actions).">Set <code>Stash 'in_limbo' reqres</code></ui>
</section>
<ui id="tabconfig.children.bucket" type="string" data-help="Use this bucket when archiving reqres originating from new tabs opened from this tab (middle mouse click, context menu actions).">Bucket</ui>
<!-- thisTabChildrenOptions -->
</div>
</section>
<section id="closed-auto-options" class="more">
<h2>Automatic actions for recently closed tabs</h2>
<div class="idots">
<!-- closedAutoOptions -->
<ui id="config.autoUnmarkProblematic" type="boolean" data-help="For a recently closed tab, automatically forget about `problematic` reqres.">Auto-unmark <code>problematic</code> reqres</ui>
<ui id="config.autoPopInLimboCollect" type="boolean" data-help="For a recently closed tab, automatically collect `in_limbo` reqres.">Auto-collect <code>in_limbo</code> reqres</ui>
<ui id="config.autoPopInLimboDiscard" type="boolean" class="prefer-off" data-help="For a recently closed tab, automatically discard `in_limbo` reqres.">Auto-discard <code>in_limbo</code> reqres</ui>
<section class="on-auto">
<ui id="config.autoTimeout" type="number" class="c" data-help="Perform automatic actions after this many seconds after the target tab is closed.">... after {}s</ui>
</section>
<!-- closedAutoOptions -->
</div>
</section>
<section id="persistence-options" class="more">
<h2>Persistence</h2>
<div class="idots">
<!-- persistenceOptions -->
<div class="stats">
<div id="div-stats.unarchived" data-help="At the moment, the number of reqres that failed to be archived via one or more of the selected archiving methods (and the sum total of all sizes of their dumps).">
<span>Failed to Archive</span>
<span>
<input type="button" id="retryUnarchived" data-help="Move all failed to archive reqres to the archival queue and then nudge the archiving sub-process awake. (Archivals that fail because of networking issues will be retried automatically every 60 seconds, others will not.) See the `Help` page for more info." value="Retry" />
</span>
<span>
<span id="stats.unarchived">0</span>
(<span id="stats.unarchived_size">0</span>)
</span>
</div>
<div id="div-stats.unstashed" data-help="At the moment, the number of reqres that failed to be stashed to local storage (and the sum total of all sizes of their dumps). Note that this number does not include reqres for which stashing was not even attempted, that number is not tracked at the moment.">
<span>Failed to Stash</span>
<span>
<input type="button" id="retryUnstashed" data-help="Retry stashing of all reqres that failed to be stashed to local storage." value="Retry" />
</span>
<span>
<span id="stats.unstashed">0</span>
(<span id="stats.unstashed_size">0</span>)
</span>
</div>
<div id="div-stats.exportedAs" data-help="From the last reset, the number of reqres that were successfully archived by being exported via `saveAs` mechanism as fake-Downloads (and the sum total of all sizes of their dumps).">
<span>Exported via <code>saveAs</code></span>
<span>
</span>
<span>
<span id="stats.exportedAs">0</span>
(<span id="stats.exportedAs_size">0</span>)
</span>
</div>
<div class="isubdots">
<div id="div-stats.bundledAs" data-help="At the moment, for all buckets, the total number of dumps that are ready to be exported via `saveAs` but are currently being delayed because of bundling (and the sum total of their sizes).">
<span>... not; Bundling</span>
<span>
<input type="button" id="exportAsAll" data-help="For all buckets, export all currently bundled dumps immediately." value="Export" />
</span>
<span>
<span id="stats.bundledAs">0</span>
(<span id="stats.bundledAs_size">0</span>)
</span>
</div>
</div>
<div id="div-stats.submittedHTTP" data-help="From the last reset, the number of reqres that were successfully archived by being submitted via HTTP to the archiving server (and the sum total of all sizes of their dumps).">
<span>Submitted via <code>HTTP</code></span>
<span>
</span>
<span>
<span id="stats.submittedHTTP">0</span>
(<span id="stats.submittedHTTP_size">0</span>)
</span>
</div>
<div id="div-stats.saved" data-help="At the moment, the number of reqres that were archived into browser's local storage (and the sum total of all sizes of their dumps).">
<span>Saved in LS</span>
<span>
<input type="button" id="showSaved" data-help="Show reqres currently saved in browser's local storage." value="Show" />
</span>
<span>
<span id="stats.saved">0</span>
(<span id="stats.saved_size">0</span>)
</span>
</div>
<div id="div-stats.stashed" data-help="At the moment, the number of reqres that are currently stashed in browser's local storage and thus will not be lost on reload (and the sum total of all sizes of their dumps).">
<span>Stashed in LS</span>
<span>
</span>
<span>
<span id="stats.stashed">0</span>
(<span id="stats.stashed_size">0</span>)
</span>
</div>
<div class="isubdots">
<div id="div-stats.not_stashed" data-help="Reqres that were not stashed in local storage and exist only in RAM.">
<span>... not; In RAM</span>
<span>
<input type="button" id="stashAll" data-help="Stash all `queued`, `in_limbo`, and `unarchived` reqres into browser's local storage, regardless of `Stash 'collected' reqres into local storage` and `Stash 'in_limbo' reqres` options." value="Stash" />
</span>
<span>
</span>
</div>
</div>
</div>
<ui id="config.archive" type="boolean" class="prefer-on" data-help="Automatically archive `queued` reqres into persistent storage using one or more of the following methods. Enabling more than one of the sub-options will archive the same reqres using all of the enabled methods. (If two identical copies of the same reqres ever reach `hoardy-web organize`, it will deduplicate them.) Disabling this option will keep `queued` reqres stuck in the archiving queue indefinitely. If `Stash 'collected' reqres into local storage` option above is enabled, restarting the browser or reloading the extension will not loose them, but they will still be taking up your browser's memory. Which is why you probably shouldn't disable this option, unless you want to disable this, atomically change some of the following sub-options or the `Bucket` settings below, and then enable this again.">Archive <code>collected</code> reqres</ui>
<section id="on-archive" class="on-archive">
<div class="isubdots">
<!-- archiveOptions -->
<ui id="config.archiveExportAs" type="boolean" data-help="Archive `collected` reqres by generating in-browser fake-Downloads with their dumps. If the value of the `Bundle up to MiB` option below is larger than zero, `Hoardy-Web` will export dumps in per-`bucket` bundles. I.e., while processing the archiving queue, it will continue to concatenate dumps belonging to the same `bucket` while the sum of their sizes is smaller than the value of that option and only then export the result. The values of `bucket` can be controlled by the `Bucket` settings below. See the `Help` page for more info.">Export dumps via <code>saveAs</code></ui>
<section class="on-exportAs">
<div class="isubdots">
<!-- exportAsOptions -->
<ui id="config.exportAsHumanReadable" type="boolean" data-help="Generate fake-Downloads with long human-readable filenames. Enabled by default. Disabling this will generate shorter filenames similar to those generated by `hoardy-web-sas` archiving server.">Generate human-readable filenames</ui>
<ui id="config.exportAsBundle" type="boolean" data-help="Export `queued` dumps not as single files, but as optionally compressed bundles (concatenations) of dumps. With this option enabled `Hoardy-Web` will delay export and continue to concatenate to-be-exported dumps until the resulting bundle stops matching the following conditions. Enabled by default. Disabling this while `GZip outputs` option below is enabled will worsen the resulting compression ratio. Also, disabling this will slow down your browser's UI and make it rather annoying, unless you `Pick into limbo` by default or use anti-annoyance fixes described on the `Help` page.">Bundle dumps</ui>
<section class="on-exportAsBundle">
<div class="ishiftdots">
<ui id="config.exportAsMaxSize" type="number" class="c" data-help="Continue concatenating `queued` dumps to the output bundle while the result is smaller than given size. Generated exported files can still be larger than this size when a single dump is larger than this size, in which case such dumps will be exported as separate files. Generated bundles can be smaller than this size when the other conditions here stop matching.">... up to {} MiB,</ui>
<ui id="config.exportAsInFlightTimeout" type="number" class="c" data-help="When some reqres are still in flight, delay export via `saveAs` for this many seconds in the hopes that some new requests will get `collected`, `queued`, and then bundled. Setting this to a higher value usually improves compression ratio of the outputs (when `GZip outputs` option below is set) and makes UI slightly less annoying at the cost of higher memory consumption and making it easier to loose yet unexported data.">... with <code>in_flight</code>, delay for {}s,</ui>
<ui id="config.exportAsTimeout" type="number" class="c" data-help="When no reqres are in flight, delay export via `saveAs` for this many seconds.">... otherwise, delay for {}s.</ui>
</div>
</section>
<ui id="config.gzipExportAs" type="boolean" class="prefer-on" data-help="Try compressing each `exportAs` output using GZip (with compression level 9) and use the compressed version as the output if its size is smaller than the size of non-compressed version, use the non-compressed version otherwise. Essentially, with this enabled, `Hoardy-Web` will do what `hoardy-web-sas` archiving server does, except slower, since this is done in JavaScript.">GZip outputs</ui>
<!-- exportAsOptions -->
</div>
</section>
<ui id="config.archiveSubmitHTTP" type="boolean" data-help="Archive `collected` reqres by submitting their dumps via `HTTP` by `POST`ing them to the archiving server at the URL set in the `Server URL` option. See the `Help` page for more info.">Submit dumps via <code>HTTP</code></ui>
<section class="on-submitHTTP">
<div class="isubdots">
<ui id="config.submitHTTPURLBase" type="string" data-help="URL of the archiving server we are submitting to.">Server URL</ui>
<div><span>(Compression is done server-side.)</span></div>
</div>
</section>
<ui id="config.archiveSaveLS" type="boolean" data-help="Archive `collected` reqres by saving them into browser's local storage. See the `Help` page for more info.">Save reqres into local storage</ui>
<!-- archiveOptions -->
</div>
</section>
<ui id="config.stash" type="boolean" class="prefer-on" data-help="Automatically backup stuck `queued` and `unarchived` reqres into browser's local storage. With this option enabled `Hoardy-Web` will keep `collected` but not yet archived reqres across browser restarts and extension reloads. See also `Stash 'in_limbo' reqres` options below. See the `Help` page for more info.">Stash <code>collected</code> reqres into local storage</ui>
<section class="on-LS">
<h3>Stashing and/or saving into local storage</h3>
<div class="isubdots">
<!-- lsOptions -->
<ui id="config.preferIndexedDB" type="boolean" data-help="Prefer `IndexedDB` API to `storage.local` API for stashing and saving new reqres, if both are available. `Hoardy-Web` uses less memory and disk IO when loading data back to memory via `IndexedDB` API. On Firefox, this option can not be enabled if `IndexedDB` API is unavailable, which will be the case if you enable `Always use private browsing mode` browser setting, unless you use a very recent non-ESR version of Firefox. Enabling private browsing mode on older Firefox versions will also make all the data stored in `IndexedDB` suddenly unavailable, see the `Help` page for instructions how to fix that situation. On Chromium, at the moment, this option can not be disabled, since `storage.local` API there can not store `Uint8Array`s. Which is why this option is enabled by default on Chromium and disabled by default on Firefox.">Prefer <code>IndexedDB</code> API</ui>
<ui id="config.gzipLSDumps" type="boolean" class="prefer-on" data-help="Before writing each new dump to local storage, try compressing it with GZip and use the compressed version if its size is smaller than the size of non-compressed version. This applies universally, to both stashing and saving to local storage using any available API. Enabled by default since this saves a lot of disk space when archiving to local storage is enabled (see `Save reqres into local storage` option above). You might want to disable this if you run `Hoardy-Web` on a system with a slow CPU or if you sometimes temporarily stash (see `Stash 'collected' reqres into local storage` option above and `Stash 'in_limbo' reqres` options below) but almost never archive data to local storage. Since, in the latter case, GZipping everything twice would be a waste of CPU cycles (once when stashing, and then the second time when exporting and/or on the archiving server side).">GZip dumps</ui>
<!-- lsOptions -->
</div>
</section>
<!-- persistenceOptions -->
</div>
</section>
<section id="behaviour-options" class="more">
<h2>Behaviour</h2>
<div class="idots">
<!-- behaviourOptions -->
<ui id="config.history" type="number" class="c" data-help="Remember at most this many `collected` and `discarded` reqres in the log. Making this larger will increase memory consumption.">Log at most {} reqres</ui>
<ui id="config.autoReloadOnUpdates" type="boolean" data-help="When the browser has a new version of `Hoardy-Web` fetched and ready to go, automatically reload `Hoardy-Web` to update. See the `Reload` button (the button with an awfully excited face emoji) above for more info. Disabled by default because this feature is experimental at the moment.">Auto-reload on updates</ui>
<section id="work-offline-url-options">
<h3>"Work offline" mode</h3>
<div class="isubdots">
<ui id="config.workOfflineFile" type="boolean" data-help="Automatically enable `This tab > Work offline` option in a tab when it navigates to a `file:` URL. This mainly exists to prevent pages produced by `hoardy-web export mirror` from accessing the Internet. See the `Help` page for more info.">Force <code>Work offline</code> in <code>file:</code> tabs</ui>
<ui id="config.workOfflineData" type="boolean" data-help="Automatically enable `This tab > Work offline` option in a tab when it navigates to a `data:` URL. See the `Help` page for more info.">Force <code>Work offline</code> in <code>data:</code> tabs</ui>
</div>
</section>
<section id="firefox-options" class="on-firefox">
<h3>Workarounds for Firefox issues</h3>
<div class="isubdots">
<ui id="config.workaroundFirefoxFirstRequest" type="boolean" data-help="Cancel and restart the very first non-background request Firefox makes. See the "Quirks and Bugs" section of the `Help` page for details.">Restart the very first request</ui>
</div>
</section>
<section id="chromium-options" class="on-chromium">
<h3>Workarounds for Chromium issues</h3>
<div class="isubdots">
<ui id="config.workaroundChromiumDebugTimeout" type="number" class="c" data-help="Wait this many seconds for Chromium to generate new debugging or webRequest events before giving up and forcefully finishing all unmatched in-flight reqres. See the "Quirks and Bugs" section of the `Help` page for details. Make this larger if your system is slow in general or if `Hoardy-Web` generates duplicated reqres for the same fetched URL.">Delay reqres for {} s</ui>
<ui id="config.workaroundChromiumResetRootTab" type="boolean" class="prefer-on" data-help="Reset new tabs opened via browser's "New Tab" browser action (new tabs created via the plus sign in the tab bar, `Control+T`, `New Tab` menu item) to the URL below. You can disable this, but then `Hoardy-Web` will proceed trying to collect the first page the browser loads there, which will probably fail.">Reset new root tabs</ui>
<div class="isubdots">
<ui id="config.workaroundChromiumResetRootTabURL" type="string" data-help="URL of the first page in a new tab. Setting this to `about:blank` is highly recommended.">... to URL</ui>
</div>
</div>
</section>
<!-- behaviourOptions -->
</div>
</section>
<section id="ui-options" class="more">
<h2>User Interface</h2>
<div class="idots">
<!-- uiOptions -->
<ui id="config.colors" type="tristate" data-help="Color scheme tristate: light mode, browser's default, dark mode.">Color scheme</ui>
<ui id="config.colorblind" type="boolean" data-help="Use bluish colors instead of greenish where possible.">Colorblind mode</ui>
<ui id="config.seasonal" type="boolean" data-help="Allow `Hoardy-Web` to use seasonal themes. Disabling this will forbid the use of the following sub-options, including those that might be added here in future versions of `Hoardy-Web`. Enabled by default. You might want to disable this if you hate fun.">Allow seasonal theming</ui>
<section class="on-seasonal">
<div class="isubdots">
<ui id="config.season.halloween" type="tristate" data-help="Tristate controlling the use of the "Halloween" theme: disabled, enabled when close to Halloween, enabled. When enabled, this theme will force the dark mode theme regardless of what the `Color scheme` setting above says.">🦇 Halloween mode</ui>
</div>
</section>
<ui id="config.pureText" type="boolean" data-help="Do not use emojis in UI labels. Makes screen readers happier.">Use pure text labels</ui>
<ui id="config.animateIcon" type="number" class="c" data-help="When `Hoardy-Web` wants to display more than one toolbar icon, switch them every this many milliseconds.">Animate toolbar icon every {}ms</ui>
<section class="on-mobile">
<ui id="config.spawnNewTabs" type="boolean" data-help="Open the other pages of this extension in newly created tabs instead of reusing the current window. This is enabled by default and can not disabled when `Hoardy-Web` runs on a desktop browser. This is disabled by default when `Hoardy-Web` runs on a mobile browser.">Spawn internal pages in new tabs</ui>
</section>
<section id="notification-options">
<ui id="config.verbose" type="boolean" data-help="Produce more verbose notifications. Enabled by default for on-boarding new users. You can safely disable this if you are aware that almost anything `Hoardy-Web` does can be changed by one of its settings, and/or if long notifications annoy you by taking a lot of screen area and/or speech time of you TTS engine.">Generate verbose notifications</ui>
<h3>Generate notifications about</h3>
<div class="isubdots">
<ui id="config.hintNotify" type="boolean" class="prefer-on c" data-help="Generate notifications explaining various non-obvious things `Hoardy-Web` does.">... {} UI hints</ui>
<section class="on-mobile">
<ui id="config.invisibleUINotify" type="boolean" class="c" data-help="Generate notifications about actions that are quirky on mobile browsers. This only has an effect if `Hoardy-Web` runs on a mobile browser like Fenix/Fennec/Mull/etc.">... {} mobile UI quirks</ui>
</section>
<ui id="config.problematicNotify" type="boolean" class="c" data-help="Complain when a new `problematic` reqres appears.">... {} new <code>problematic</code> reqres</ui>
<section class="on-problematicNotify">
<div class="isubdots">
<ui id="config.problematicNotifyNumber" type="number" class="c" data-help="Show no more than this many latest METHOD + URL lines in the generated `problematic` reqres notification.">... but no more than {} lines</ui>
</div>
</section>
<ui id="config.limboNotify" type="boolean" class="c" data-help="Complain when too much stuff is being held in limbo. You can safely disable this or set the following sub-options to absurdly high values if `Stash 'collected' reqres into local storage` and all `Stash 'in_limbo' reqres` options are set.">... {} too much stuff in <code>in_limbo</code> state</ui>
<section class="on-limboNotify">
<div class="ishiftdots">
<ui id="config.limboMaxNumber" type="number" class="c" data-help="Start complaining when more than this number of reqres are in `in_limbo` state.">... after {} elements,</ui>
<ui id="config.limboMaxSize" type="number" class="c" data-help="Start complaining when the total size of all dumps in `in_limbo` state is larger than this many Megabytes.">... or {} MiB</ui>
</div>
</section>
<ui id="config.autoNotify" type="boolean" class="prefer-on c" data-help="Generate a notification when an automatic action was performed in background.">... {} automatic actions</ui>
<ui id="config.archiveStuckNotify" type="boolean" class="prefer-on c" data-help="Complain when the archival queue is not empty but both `Archive 'collected' reqres` and `Stash 'collected' reqres into local storage` options are disabled.">... {} unstashed stuck archival queue</ui>
<ui id="config.archiveFailedNotify" type="boolean" class="prefer-on c" data-help="Complain when some reqres fail to be stashed or archived to persistent storage (browser's local storage, the archival server, etc).">... {} archival errors</ui>
<ui id="config.archiveDoneNotify" type="boolean" class="c" data-help="Generate an "All OK" notification when the archival queue becomes empty the very first time or after a previous archival failure. This exists mostly for on-boarding new users.">... {} newly empty archival queue</ui>
</div>
</section>
<!-- uiOptions -->
</div>
</section>
<section id="debugging-options" class="more">
<h2>Debugging</h2>
<div class="idots">
<!-- debuggingAutoOptions -->
<div class="stats">
<div id="div-stats.errored" data-help="At the moment, the number of reqres for which `Hoardy-Web` produced internal errors. Basically, the number of reqres that hit bugs in `Hoardy-Web`.">
<span>Errored</span>
<span>
<input type="button" id="forgetErrored" data-help="Forget about all these reqres." value="Forget" />
</span>
<span>
<span id="stats.errored">0</span>
(<span id="stats.errored_size">0</span>)
</span>
</div>
</div>
<ui id="config.ephemeral" type="boolean" class="prefer-off" data-help="Make all changes to settings in this popup ephemeral from this point on. Restarting the browser or reloading the extension will reset config to the last state when this setting was off.">Ephemeral settings</ui>
<ui id="config.debugging" type="boolean" class="prefer-off" data-help="Report lots of data into extension's debugging log (in Firefox: about:debugging; in Chromium: extension inspector). This will make things very slow and will eat lots of memory. Do not enable unless you know what you are doing.">Verbose debugging log (SLOW!)</ui>
<ui id="config.dumping" type="boolean" class="prefer-off" data-help="Dump raw CBOR reqres dumps into extension's debugging log. Makes things even slower and eats even more memory. Do not enable unless you know what you are doing.">Dump raw CBORs into the log</ui>
<ui id="config.snapshotAny" type="boolean" class="prefer-off" data-help="Try capturing DOM snapshots for tabs and frames with all URLs, including `about:`, `data:`, `file:`, and extension pages. If you enable this, expect to see a lot of snapshot capture errors.">Capture snapshots of all URLs</ui>
<ui id="config.discardAll" type="boolean" class="prefer-off" data-help="Automatically discard all reqres instead of archiving them. Useful for debugging most of the machinery of `Hoardy-Web` without actually archiving anything. Do not enable unless you know what you are doing.">Discard all reqres just before archival</ui>
<section id="destructive-actions" class="more">
<!-- destructiveOptions -->
<h3>Destructive actions</h3>
<div class="flex">
<span class="center">
<input type="button" id="resetConfig" data-help="Reset all config options to their default values." value="Reset config!" />
<input type="button" id="resetPersistentStats" data-help="Reset all persistent `collected`, `discarded`, `picked`, and `dropped` stats to zero." value="Reset stats!" />
</span>
<!-- destructiveOptions -->
</div>
</section>
<!-- debuggingAutoOptions -->
</div>
</section>
<div class="flex">
<input type="button" id="showAll" class="less" tabindex=1 value="Show all" />
</div>
<!-- idBody -->
</div>
<script src="../lib/compat.js"></script>
<script src="../lib/utils.js"></script>
<script src="../lib/lutils.js"></script>
<script src="popup.js"></script>
</body>
</html>