coldwire-rails 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e48a15a424535143cc620dbbe65eec4a367c9e1feaa60addc104587ee835c836
-  data.tar.gz: b85fc7cfc8b80db94b14e994afbb258cc997d0b161986738e80c33a8a49704d5
+  metadata.gz: 7b29177b5dd7843a32faa8d813d3e69cbac5e17c080740944203d0b441fd9fd2
+  data.tar.gz: 5a0623dd26cce626b03e899aacba3cf4514423dd204609d7a6be214b619bc78c
 SHA512:
-  metadata.gz: 543c39e2d9999a45ce8041d4c87cb2853908056611bdc189d49e0fde87309373260131f433f92715d29943fcd44eb1d429aa6f270ef639287c0d45ce86787f11
-  data.tar.gz: 31bc9a01f008bd987c79700058b49682cae9d1020e873bf9aab03949fe9d15d9619c420c7b5c9efe7032a6b07eddaa090b54d43adecd9cf2f503983d4e702632
+  metadata.gz: c97aaf5882d7203931d463a8f9f0bb825bea50c5b8ddd5871db33411587359d1caf943c51d19f8a7629ac152b5310d466dc9504e078e9e7d47212202dbe796b7
+  data.tar.gz: 5be03d9e50e9cb0f85e7ae4a4233a65a249b709f4c9eb994a2c2b699fdb682a8d4350e087d1674be978b6ec22ecbd500c2e3a634b88eda91ddcc9c49168c011b

data/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 ## [Unreleased]
 
+## [0.5.0]
+
+- **A Turbo Frame is cached apart from its page.** A frame navigation used to overwrite the
+  page at the same URL, so a later visit got a fragment as a whole document — a blank screen,
+  and in Hotwire Native no `window.Turbo`. Frame requests now take their own entry first and
+  the page second, the way Turbo does online.
+- **Every `respond_to` format is cached apart from the page.** One URL answering HTML, JSON,
+  CSV, or RSS no longer shares a single slot. A path that already names its format
+  (`/report.json`, `/app.css`) is left alone. A request asking for data gets data or nothing,
+  never the page.
+- **The precache manifest can name a frame or a format.** A listing may be a Hash:
+  `{ url: feature_path(f), frame: "map_feature_popup" }` or `{ url: report_path(r), format: :json }`.
+  `accept:` takes a media type outright. A bare URL is still the page.
+- **A Turbo Stream is never stored.** It is a list of mutations, not a page, and replaying a
+  stale one would apply yesterday's changes to today's DOM.
+
+## [0.4.0]
+
+- Updated the offline page to restructure storage and downloads.
+- Updated the storage so when you change storage size it triggers a garbage collection.
+
 ## [0.3.0]
 
 - **`cache_origins` is `cacheable_hosts`**, and takes bare hosts: `"tiles.example.com"` rather
@@ -25,14 +46,8 @@ First release. The API may still change before 1.0.
   with every option and its default, registers the Stimulus controller, and tags the
   layout. Safe to run twice.
 - **Garbage collection.** `config.garbage_collection` sweeps entries nothing has used in
-  `max_age` (60 days by default) and, once the cache is over `max_size` (250 MB by default),
-  the least recently read of what is left until it fits — so a cache that fills as people
-  browse does not fill forever, on a device that revisits nothing as much as on one that
-  revisits everything. The ceiling is offered as a ladder of sizes on the offline settings
-  page and remembered per device, since how much of a phone to spend is not something an app
-  can know. It measures only what a sweep may take: downloaded archives are an opt-in spend
-  of somebody's data plan, so they are neither counted nor evicted.
-  On by default, unlike syncing: it spends no data. A sweep runs only with a
+  `max_age` (30 days by default), so a cache that fills as people browse does not fill
+  forever. On by default, unlike syncing: it spends no data. A sweep runs only with a
   connection it has confirmed by pinging `probe_path`, because deleting is the one cache
   operation with no way back. Age is measured from last use, not from when an entry was
   fetched — storing a page renews everything it names, so the stylesheet every page loads

data/README.md

@@ -25,7 +25,7 @@ Works the same in a plain  web app, an installed PWA, or Hotwire Native.
 
 ## What you get
 
-- **[Setup in 30 seconds](docs/setup.md):** Instal gem, then `bin/rails coldwire:install`. The rest has working defaults.
+- **[Setup in 30 seconds](docs/setup.md):** Install gem, then `bin/rails coldwire:install`. The rest has working defaults.
 - **[Cache as you go](docs/configuration.md#cache_as_you_go):** Defaults to all pages get cached as your navigate, customize to only cache certain parts of the app.
 - **[Auto Sycn precaching](docs/configuration.md#auto_sync):** Define urls that can be pre-cached automatically in the background.
 - **[Garbage collection](docs/configuration.md#garbage_collection):** Entries nothing has used in two months are swept, and anything over the storage ceiling goes least recently read first — so the cache doesn't grow forever. Only with a connection; anything a page still loads is renewed on the way past. People can set the ceiling for their own device on `/offline`.

data/VERSION

@@ -1 +1 @@
-0.3.0
+0.5.0

data/app/assets/javascripts/coldwire/cache_controller.js

@@ -43,6 +43,7 @@ export default class extends Controller {
     "autoSync",
     "syncedAt",
     "syncStatus",
+    "syncDetails",
     "syncButton",
     "syncLabel",
     "search",
@@ -129,6 +130,7 @@ export default class extends Controller {
 
     if (data.state === "started") {
       this.syncRunning = true
+      this.revealSync()
       const retired = data.retired ? `, retired ${data.retired}` : ""
       this.setSyncStatus(data.pending
         ? `Syncing ${data.pending} file${data.pending === 1 ? "" : "s"}${retired}…`
@@ -143,6 +145,7 @@ export default class extends Controller {
       // A page that opened mid-run arrives here without ever having seen "started", so this
       // branch has to be able to put the page into the running state on its own.
       this.syncRunning = true
+      this.revealSync()
       this.toggleSyncing(true)
       if (this.hasProgressTarget) this.progressTarget.hidden = false
       // The bar carries the live count; the line above stays on the high-level "what".
@@ -214,6 +217,7 @@ export default class extends Controller {
   async syncNow(event) {
     event?.preventDefault()
     this.syncSettled = false
+    this.revealSync()
     // Reaching the worker takes a moment, and the ticker keeps ticking while it does.
     this.syncStarting = true
     this.toggleBusy(true)
@@ -243,6 +247,13 @@ export default class extends Controller {
     }
   }
 
+  // Everything a sync has to say lives behind the disclosure, so a run has to open it — a bar
+  // filling where nobody can see it is the same as no bar. Left open afterwards: somebody who
+  // has just watched a sync is the one person who might want the detail.
+  revealSync() {
+    if (this.hasSyncDetailsTarget) this.syncDetailsTarget.open = true
+  }
+
   setSyncStatus(text) {
     if (!this.hasSyncStatusTarget) return
 
@@ -250,24 +261,24 @@ export default class extends Controller {
     this.syncStatusTarget.hidden = !text
   }
 
+  // Inside the details, under the switch that says whether syncing is on at all. This says
+  // how often, and when it is off, that the button below still works.
   renderAutoSync() {
     if (!this.hasAutoSyncTarget) return
 
-    // The switch beside this already says whether it is on, so this line carries the one
-    // thing the switch cannot: how often.
     if (!this.autoSyncValue) {
-      this.autoSyncTarget.textContent = "Automatic syncing is off"
+      this.autoSyncTarget.textContent = "Runs only when you press Sync now."
       return
     }
 
     if (!this.autoSyncOn()) {
-      this.autoSyncTarget.textContent = "Off for this device"
+      this.autoSyncTarget.textContent = "Off for this device. Sync now still runs a pass."
       return
     }
 
     this.autoSyncTarget.textContent = this.syncIntervalValue > 0
-      ? `Syncs every ${formatInterval(this.syncIntervalValue)}`
-      : "On"
+      ? `Syncs every ${formatInterval(this.syncIntervalValue)}.`
+      : "On."
   }
 
   renderSyncedAt() {
@@ -428,6 +439,7 @@ export default class extends Controller {
       // What this page can answer by itself comes first: the cache is read directly and the
       // probe is one request. Behind the worker questions they waited out a registration that
       // may never arrive, and the page sat on "Checking…" with an empty list.
+      await this.loadSpared()
       await this.renderCache()
       await this.renderConnection()
 
@@ -835,73 +847,93 @@ export default class extends Controller {
     select.disabled = true
 
     try {
-      // A lowered ceiling that waits for the next scheduled sweep reads as a setting that did
-      // nothing. This is that same sweep, run now — and bound by the same rule, so with no
-      // connection it stands down and the line under the bar says why.
-      await this.collectNow()
+      // A ceiling that waits for the next scheduled sweep reads as a setting that did nothing,
+      // so it is applied here and now. Deliberate, so it does not stand down for want of a
+      // connection the way an automatic sweep does.
+      await this.applyCeiling()
     } finally {
       select.disabled = false
     }
   }
 
-  async collectNow() {
-    let result = null
+  async applyCeiling() {
+    // A trim over a thousand entries is a second or two, and a silent pause reads as a
+    // setting that did nothing.
+    if (this.hasUsageLabelTarget) this.usageLabelTarget.textContent = "Applying…"
 
     try {
-      result = await sendToWorker("collect", { maxSize: this.store.maxSize() }, 60000)
-    } catch {
-      // No worker controlling this page yet. The cache is unchanged and the line already
-      // says where it stands.
+      await sendToWorker("trim", { maxSize: this.store.maxSize() }, 60000)
+    } catch (error) {
+      // Say so. Swallowing this is what turned a stale worker — one registered before the app
+      // knew what a ceiling was, and still controlling this page until it is reloaded — into
+      // a setting that silently refused to bite.
+      if (this.hasUsageLabelTarget) {
+        this.usageLabelTarget.textContent = `Could not apply it: ${error.message}. Reload and try again.`
+      }
       return
     }
 
-    // Nothing was swept, so the clock stays where it is and the next page load finds the
-    // sweep still due — exactly as the head snippet treats a refused run.
-    this.sweepWaiting = Boolean(result?.offline)
-    if (!this.sweepWaiting) this.store.set(this.store.keys.collectedAt, Date.now())
-
+    await this.loadSpared()
     await this.renderCache()
   }
 
-  // What the ceiling is measured against: everything but the downloads, which are an opt-in
-  // spend of somebody's data plan and are never collected however full the cache gets — a
-  // 300 MB archive counted here would show a bar pinned full of files no sweep can touch.
+  // The worker is the only thing that knows what the offline page needs, and those entries are
+  // never collected. Read once and kept: it does not change while this page is open.
+  async loadSpared() {
+    try {
+      const result = await sendToWorker("spared", {}, 5000)
+      this.spared = new Set(result?.urls || [])
+    } catch {
+      // An older worker, or none yet. Falling back to counting everything overstates what a
+      // sweep can take, which is the safer direction for a figure somebody sets a limit from.
+      this.spared = this.spared || new Set()
+    }
+  }
+
+  // What the ceiling is measured against, which has to be what a sweep can actually take, or
+  // the bar shows an overage nothing will ever bring down. Three exclusions:
+  //
+  // Downloads, an opt-in spend of somebody's data plan, are never collected however full the
+  // cache gets — a 300 MB archive counted here would pin the bar full of untouchable files.
+  // Their sizes are on their own rows, which is where somebody reclaims that space.
+  //
+  // The offline page's own assets, which the worker spares and names for us: working them out
+  // means parsing the offline page, and only the worker holds it.
   //
-  // The worker also spares the offline page's own assets, which this cannot pick out of a
-  // list of URLs. That is a handful of files, and erring towards the larger figure is the
-  // right way round for a number somebody is deciding a limit from.
+  // Any cache but the worker's own. Bumping cache_name leaves the old one behind, and the
+  // worker only ever sweeps the one it is configured with.
   managedBytes(entries) {
-    return this.totalBytes((entries || []).filter((entry) => !entry.download))
+    const swept = window.COLDWIRE?.cacheName
+    const spared = this.spared
+
+    return this.totalBytes((entries || []).filter((entry) =>
+      !entry.download &&
+      !(spared && spared.has(entry.url)) &&
+      (!swept || !entry.cache || entry.cache === swept)))
   }
 
   renderStorage() {
     if (!this.hasUsageLabelTarget) return
 
     const limit = this.store.maxSize()
-    const used = this.managedBytes(this.entries)
+    const managed = this.managedBytes(this.entries)
 
     if (this.hasUsageTarget) this.usageTarget.hidden = limit === null
 
     if (limit === null) {
-      this.usageLabelTarget.textContent = `${formatBytes(used)} of cached pages, with no limit set.`
-      return
-    }
+      this.usageLabelTarget.textContent = `${formatBytes(managed)} of cached pages, with no limit set.`
+    } else {
+      const percent = Math.round(Math.min(managed / limit, 1) * 100)
+      if (this.hasUsageBarTarget) this.usageBarTarget.style.width = `${percent}%`
+      if (this.hasUsageTarget) this.usageTarget.setAttribute("aria-valuenow", String(percent))
 
-    const percent = Math.round(Math.min(used / limit, 1) * 100)
-    if (this.hasUsageBarTarget) this.usageBarTarget.style.width = `${percent}%`
-    if (this.hasUsageTarget) this.usageTarget.setAttribute("aria-valuenow", String(percent))
-
-    const parts = [ `${formatBytes(used)} of ${formatLimit(limit)}` ]
-    if (used > limit) {
-      // Over the ceiling is not a fault and not a promise of instant deletion: a sweep needs
-      // a connection, and says so rather than leaving somebody watching a bar that will not
-      // move.
-      parts.push(this.sweepWaiting || this.online === false
-        ? "over, waiting for a connection to sweep"
-        : "over, the oldest go on the next sweep")
-    }
+      const parts = [ `${formatBytes(managed)} of ${formatLimit(limit)} used by cached pages` ]
+      // Choosing a ceiling applies it on the spot, so this is what is left between sweeps: a
+      // cache that has grown past a ceiling nobody has touched since. The next sweep takes it.
+      if (managed > limit) parts.push("over, the oldest go on the next sweep")
 
-    this.usageLabelTarget.textContent = `${parts.join(" · ")}.`
+      this.usageLabelTarget.textContent = `${parts.join(" · ")}.`
+    }
   }
 
   renderEntries() {

data/app/controllers/coldwire/caches_controller.rb

@@ -12,7 +12,7 @@ module Coldwire
     def pack
       response.headers["Cache-Control"] = "no-store, private"
 
-      render json: { urls: Array(precache_urls) }
+      render json: { urls: Coldwire.precache_entries(precache_urls) }
     end
 
     private

data/app/views/coldwire/caches/show.html.erb

@@ -81,7 +81,7 @@
       <span>
         <span class="coldwire-setting-title">Offline support</span>
         <span class="coldwire-setting-note">
-          Cache pages so they work without a connection.
+          Enable page caching so they work without a connection.
         </span>
       </span>
     </label>
@@ -102,11 +102,84 @@
           </span>
         </span>
       </label>
+
+      <%# Syncing sits with the other two switches rather than in a card of its own: all three
+          are the same kind of thing, a choice this device makes about how Coldwire behaves. %>
+      <hr>
+
+      <% if Coldwire.config.auto_sync.enabled %>
+        <%# Only where the app configured automatic syncing at all: a switch for something that
+            was never going to happen is a switch that lies. %>
+        <label class="coldwire-setting">
+          <span class="coldwire-switch coldwire-switch--on">
+            <input type="checkbox"
+                   data-coldwire-cache-target="autoSyncToggle"
+                   data-action="change->coldwire-cache#toggleAutoSync">
+            <span aria-hidden="true"></span>
+          </span>
+          <span>
+            <span class="coldwire-setting-title">Sync on its own</span>
+            <span class="coldwire-setting-note">
+              Automatically back up pages in the background.
+            </span>
+          </span>
+        </label>
+      <% else %>
+        <p class="coldwire-facts" style="margin-top: 0;">
+          Automatically back up pages in the background.
+          <strong>Sync now</strong> runs a pass immediately.
+        </p>
+      <% end %>
+
+      <%# The clock, the button and the bar behind a disclosure. They are worth having, and
+          worth going to: under a switch you are not using they are three lines of furniture
+          on every visit. It opens itself while a sync runs, so progress is never hidden
+          behind a tap nobody knew to make. %>
+      <details class="coldwire-sync" data-coldwire-cache-target="syncDetails">
+        <summary><span>Sync details</span></summary>
+
+        <div class="coldwire-sync-body">
+          <%# How often, which the switch cannot show and the note above no longer says. %>
+          <p class="coldwire-facts" data-coldwire-cache-target="autoSync">Checking…</p>
+          <p class="coldwire-facts" data-coldwire-cache-target="syncedAt">Never synced</p>
+
+          <%# Empty until a sync has something to say, so the card does not carry a permanent
+              "Idle" that reads like debug output left in by accident. %>
+          <p class="coldwire-facts" data-coldwire-cache-target="syncStatus" hidden></p>
+
+          <div class="coldwire-actions coldwire-actions--spaced">
+            <button type="button"
+                    data-coldwire-cache-target="syncButton"
+                    class="coldwire-button"
+                    data-action="click->coldwire-cache#syncNow">
+              <span class="coldwire-spinner" data-coldwire-cache-target="spinner" aria-hidden="true" hidden></span>
+              <span data-coldwire-cache-target="syncLabel">Sync now</span>
+            </button>
+          </div>
+
+          <div style="margin-top: 0.75rem;"
+               role="progressbar"
+               aria-valuemin="0"
+               aria-valuemax="100"
+               data-coldwire-cache-target="progress"
+               hidden>
+            <div class="coldwire-track">
+              <div class="coldwire-bar" data-coldwire-cache-target="progressBar"></div>
+            </div>
+            <div class="coldwire-progress-label" data-coldwire-cache-target="progressLabel"></div>
+          </div>
+        </div>
+      </details>
     </div>
   </div>
 
   <div data-coldwire-cache-target="whenOn">
   <% gc = Coldwire.config.garbage_collection %>
+  <% archives = Coldwire.config.cache_archives %>
+  <%# Two cards, because they answer two questions. This one is what the app keeps as you
+      browse and how much of it you will allow; the next is what you chose to keep yourself.
+      One card had the first card's figure sitting a finger's width from files it does not
+      count, which read as an error in the figure. %>
   <% if gc.enabled %>
     <%# What the cache is allowed to grow to on this device. The choice is remembered here the
         way Force offline and Sync on its own are — the app sets the starting point, the person
@@ -150,94 +223,61 @@
       </div>
 
       <p class="coldwire-facts" data-coldwire-cache-target="usageLabel">Reading the cache…</p>
+
+      <% if archives.any? %>
+        <%# Said where the question comes up. Somebody reading a figure that does not match the
+            one in the header is owed the reason on the spot, not a card further down. This
+            line is about what the figure counts; what becomes of a download is the other
+            card's business, and saying it twice made both cards read as hedging. %>
+        <p class="coldwire-downloads-note">
+          Cached pages only. Downloads are counted separately, under Downloads below.
+        </p>
+      <% end %>
     </div>
   <% end %>
 
-  <div class="coldwire-card">
-    <h2>Auto Sync</h2>
+  <% if archives.any? %>
+    <%# One row per configured file, each reporting its own size. The words are the app's — the
+        page knows only that these are large, optional, and worth keeping. %>
+    <div class="coldwire-card coldwire-downloads" data-coldwire-cache-target="archives">
+      <h2>Downloads</h2>
 
-    <% if Coldwire.config.auto_sync.enabled %>
-      <%# Only where the app configured automatic syncing at all: a switch for something that
-          was never going to happen is a switch that lies. The card leads with it and lets its
-          note do the explaining, the way Force offline does. %>
-      <label class="coldwire-setting">
-        <span class="coldwire-switch coldwire-switch--on">
-          <input type="checkbox"
-                 data-coldwire-cache-target="autoSyncToggle"
-                 data-action="change->coldwire-cache#toggleAutoSync">
-          <span aria-hidden="true"></span>
-        </span>
-        <span>
-          <span class="coldwire-setting-title">Sync on its own</span>
-          <span class="coldwire-setting-note">
-            Automatically runs in the background backing up pages to be used offline.
-          </span>
-        </span>
-      </label>
-    <% else %>
-      <p class="coldwire-facts" style="margin-top: 0;">
-        Automatically runs in the background backing up pages to be used offline.
-        <strong>Sync now</strong> runs that pass immediately.
-      </p>
-    <% end %>
-
-    <p class="coldwire-facts">
-      <span data-coldwire-cache-target="autoSync">Checking…</span><br>
-      <span data-coldwire-cache-target="syncedAt">Never synced</span>
-    </p>
-
-    <%# Empty until a sync has something to say, so the card does not carry a permanent
-        "Idle" that reads like debug output left in by accident. %>
-    <p class="coldwire-facts" data-coldwire-cache-target="syncStatus" hidden></p>
-
-    <div class="coldwire-actions coldwire-actions--spaced">
-      <button type="button"
-              data-coldwire-cache-target="syncButton"
-              class="coldwire-button"
-              data-action="click->coldwire-cache#syncNow">
-        <span class="coldwire-spinner" data-coldwire-cache-target="spinner" aria-hidden="true" hidden></span>
-        <span data-coldwire-cache-target="syncLabel">Sync now</span>
-      </button>
-    </div>
+      <%# The name and what you can do about it on one line, the words underneath. The button
+          sits hard right, where the eye goes for the action, and what is happening reads under
+          both when a download is running. %>
+      <% archives.each do |archive| %>
+        <div class="coldwire-archive" data-archive-url="<%= archive[:url] %>">
+          <div class="coldwire-archive-head">
+            <div class="coldwire-archive-title"><%= archive[:title] %></div>
 
-    <div style="margin-top: 0.75rem;"
-         role="progressbar"
-         aria-valuemin="0"
-         aria-valuemax="100"
-         data-coldwire-cache-target="progress"
-         hidden>
-      <div class="coldwire-track">
-        <div class="coldwire-bar" data-coldwire-cache-target="progressBar"></div>
-      </div>
-      <div class="coldwire-progress-label" data-coldwire-cache-target="progressLabel"></div>
-    </div>
-  </div>
+            <div class="coldwire-actions coldwire-archive-actions">
+              <button type="button" class="coldwire-button"
+                      data-url="<%= archive[:url] %>"
+                      data-action="click->coldwire-cache#downloadArchive">
+                <span class="coldwire-spinner" data-archive-spinner aria-hidden="true" hidden></span>
+                <span data-archive-download-label>Download</span>
+              </button>
+              <%# Unlabelled but for its shape, as the trash is everywhere else on this page,
+                  so the pair fits beside the title rather than under it. %>
+              <button type="button"
+                      class="coldwire-button coldwire-icon-button coldwire-button--danger"
+                      title="Delete this download"
+                      aria-label="Delete <%= archive[:title] %>"
+                      data-url="<%= archive[:url] %>"
+                      data-action="click->coldwire-cache#removeArchive"
+                      data-archive-remove hidden>
+                <svg viewBox="0 0 24 24" aria-hidden="true">
+                  <path stroke-linecap="round" stroke-linejoin="round" d="<%= trash_path %>" />
+                </svg>
+              </button>
+            </div>
+          </div>
 
-  <% if Coldwire.config.cache_archives.any? %>
-    <%# One row per configured file. The words are the app's — the page knows only that these
-        are large, optional, and worth keeping. %>
-    <div class="coldwire-card" data-coldwire-cache-target="archives">
-      <% Coldwire.config.cache_archives.each do |archive| %>
-        <div class="coldwire-archive" data-archive-url="<%= archive[:url] %>">
-          <div class="coldwire-archive-title"><%= archive[:title] %></div>
+          <%# The words run the full width under both, rather than in a column the button has
+              squeezed to three syllables a line. %>
           <% if archive[:description].present? %>
             <p class="coldwire-facts"><%= archive[:description] %></p>
           <% end %>
-          <div class="coldwire-actions">
-            <button type="button" class="coldwire-button"
-                    data-url="<%= archive[:url] %>"
-                    data-action="click->coldwire-cache#downloadArchive">
-              <span class="coldwire-spinner" data-archive-spinner aria-hidden="true" hidden></span>
-              <span data-archive-download-label>Download</span>
-            </button>
-            <button type="button" class="coldwire-button coldwire-button--danger"
-                    data-url="<%= archive[:url] %>"
-                    data-action="click->coldwire-cache#removeArchive"
-                    data-archive-remove hidden>
-              Delete
-            </button>
-          </div>
-
           <p class="coldwire-facts coldwire-archive-meta" data-archive-status>Checking…</p>
 
           <div style="margin-top: 0.75rem;" role="progressbar" aria-valuemin="0" aria-valuemax="100"
@@ -247,6 +287,15 @@
           </div>
         </div>
       <% end %>
+
+      <% if gc.enabled %>
+        <%# The reassurance belongs with the files it is about: a 300 MB download sitting under
+            a storage limit raises the question of whether the app is about to take it back. %>
+        <p class="coldwire-downloads-note">
+          Yours until you delete them. <strong>Keep at most</strong> never counts a download,
+          and never clears one to make room.
+        </p>
+      <% end %>
     </div>
   <% end %>
 

data/app/views/coldwire/service_worker/show.js.erb

@@ -26,6 +26,17 @@ const CACHE_RANGES = compileRules(<%= raw Coldwire.cache_rules(Coldwire.config.c
 // A range entry is stored under its own key, with the range in the query and the archive's
 // total size in a header — the two things needed to rebuild a 206 that was never storable.
 const RANGE_PARAM = "__coldwire_range"
+// Turbo sends `Turbo-Frame` on a frame navigation, and an app that answers it with just the
+// frame returns something that is not the page at that URL. Keyed apart, the same way, or one
+// would answer for the other: a fragment served to a cold visit is a document with no <html>.
+const FRAME_PARAM = "__coldwire_frame"
+// And the same URL answers a `respond_to` block in as many formats as the app defines. A page
+// is the default and carries no param, so every entry stored before this existed keeps the key
+// it already had; anything else names what it is.
+const FORMAT_PARAM = "__coldwire_format"
+// A stream is a list of changes to make to a page, not a page. Replaying a stale one later
+// would apply yesterday's mutations to today's DOM, so it is never stored at all.
+const STREAM_TYPE = "text/vnd.turbo-stream.html"
 // Archives offered for download in full, and the size of the pieces they arrive in. 8 MB is
 // small enough that a dropped connection loses seconds rather than minutes, and large enough
 // that a 300 MB archive is tens of requests rather than thousands.