sealkeep 0.5.0

package/web/rail.js

@@ -0,0 +1,308 @@
+/**
+ * The rail's identity strip, shared by every page.
+ *
+ * One implementation on purpose: the card first shipped inside app.js, so the
+ * dashboard showed "Sealkeep Pro · 1.9 GB of 500 GB" while Sessions and
+ * Retention showed nothing — the rail visibly lost its top on every page
+ * change and the nav items jumped to fill the space. Any page with the
+ * `.acct` markup and an `api(path)` helper can render the same card with one
+ * call; pages without the markup are a no-op, never an error.
+ */
+function renderAccountRail(api, status) {
+  const $id = (id) => document.getElementById(id);
+  const card = $id("acct-card");
+  if (!card) return Promise.resolve();
+
+  // Identical to the app's own bytes(): binary units, one decimal. The first
+  // version divided by 1e9, so the same quota read "536.9 GB" in this card and
+  // "500.0 GB" in the account panel — two numbers for one fact.
+  const bytes = (n) => {
+    const value = Number(n);
+    if (!Number.isFinite(value)) return "—";
+    const units = ["B", "KB", "MB", "GB", "TB"];
+    let size = value, unit = 0;
+    while (size >= 1024 && unit < units.length - 1) { size /= 1024; unit += 1; }
+    return `${unit === 0 ? size : size.toFixed(1)} ${units[unit]}`;
+  };
+
+  // The card is a fixed skeleton: the markup reserves every slot, and this
+  // function only ever overwrites text in place — nothing appears or grows, so
+  // the nav below never jumps. Two paints: first from the last visit's
+  // snapshot (instant, this browser already knew these numbers), then from the
+  // live answer, which also refreshes the snapshot.
+  const SNAPSHOT_KEY = "vaultline.railSnapshot";
+  const paintIdentity = (snap) => {
+    const plan = snap.plan;
+    const isPro = plan === "pro" || plan === "pro_lite";
+    $id("acct-plan").className = `acct-plan${isPro ? " pro" : ""}`;
+    $id("acct-plan-name").textContent = plan === "pro" ? "Sealkeep Pro" : plan === "pro_lite" ? "Sealkeep Pro Lite" : plan ? plan.replace(/^./, (c) => c.toUpperCase()) : "Local vault";
+    const emailEl = $id("acct-email");
+    if (emailEl) emailEl.textContent = snap.email || "no account — this machine only";
+    if (snap.limit) {
+      const used = Number(snap.used) || 0;
+      $id("acct-fill").style.width = `${Math.min(100, (used / snap.limit) * 100).toFixed(1)}%`;
+      // A remembered answer is labelled as remembered, never passed off as live.
+      $id("acct-usage").textContent = `${bytes(used)} of ${bytes(snap.limit)}${snap.cached ? " · last known" : ""}`;
+    } else {
+      $id("acct-fill").style.width = "0%";
+      $id("acct-usage").textContent = snap.plan ? "—" : "nothing stored off this machine";
+    }
+    if (snap.diskText) railWriteDiskFact(snap.diskText);
+    if (snap.panelUrl && snap.plan) railPlaceDoor(card, snap.panelUrl);
+  };
+  try {
+    const remembered = sessionStorage.getItem(SNAPSHOT_KEY);
+    if (remembered) paintIdentity({ ...JSON.parse(remembered), cached: true });
+  } catch { /* a torn snapshot paints nothing; the live answer is seconds away */ }
+
+  const ready = status ? Promise.resolve(status) : api("/v1/status");
+  return ready.then((state) => {
+    const plan = state.plan;
+    const quota = state.quota;
+    const snapshot = {
+      plan,
+      email: state.accountEmail || null,
+      used: quota ? Number(quota.usedBytes) || 0 : null,
+      limit: quota && quota.quotaBytes ? Number(quota.quotaBytes) : null,
+      cached: state.planSource === "cache",
+      panelUrl: state.panelUrl || null
+    };
+    paintIdentity(snapshot);
+    try {
+      const prior = JSON.parse(sessionStorage.getItem(SNAPSHOT_KEY) || "{}");
+      sessionStorage.setItem(SNAPSHOT_KEY, JSON.stringify({ ...snapshot, diskText: prior.diskText || null }));
+    } catch { /* a browser refusing storage costs only the instant repaint */ }
+
+    // The two facts come from setup state; tolerate its absence rather than
+    // blocking the card.
+    return api("/v1/setup/state").catch(() => null).then((setup) => {
+      const held = Boolean(setup && setup.vault && setup.vault.phraseRemembered);
+      $id("acct-phrase").className = held ? "good" : "warn";
+      $id("acct-phrase-text").innerHTML = held ? "Seals on its own" : "<b>Phrase not stored</b> — Settings";
+
+      const provider = (state.remoteStorage && state.remoteStorage.provider) || (setup && setup.storage && setup.storage.provider);
+      const label = provider
+        ? { s3: "Amazon S3", r2: "Cloudflare R2", b2: "Backblaze B2", gcs: "Google Cloud", vaultline: "Sealkeep managed" }[provider] || provider
+        : (plan ? "Sealkeep managed" : null);
+      $id("acct-storage").className = label ? "good" : "";
+      $id("acct-storage-text").textContent = label ? `Storage: ${label}` : "This disk only";
+
+      // A paying plan gets its door: the panel where the subscription,
+      // machines and stored copies are managed. The slot for it is reserved in
+      // the markup, so the door appearing changes nothing around it.
+      if (state.plan && state.panelUrl) railPlaceDoor(card, state.panelUrl);
+
+      // Without a plan, the control plane may have an offer to show — the
+      // content is the backend's, so what appears (and whether) is edited
+      // there, never shipped in this file. Dismissing one offer stays
+      // dismissed until the backend publishes a different one (new id).
+      if (!state.plan && !document.getElementById("rail-offer")) {
+        return api("/v1/offer").catch(() => null).then((body) => {
+          const offer = body && body.offer;
+          if (!offer || !offer.headline) return;
+          const dismissed = localStorage.getItem("vaultline.offer.dismissed");
+          if (dismissed && String(offer.id) === dismissed) return;
+          const box = document.createElement("div");
+          box.id = "rail-offer";
+          box.className = "rail-offer";
+          const head = document.createElement("b");
+          head.textContent = offer.headline;
+          const text = document.createElement("p");
+          text.textContent = offer.body || "";
+          const go = document.createElement("a");
+          go.className = "action";
+          go.textContent = offer.cta_label || "Learn more";
+          go.href = offer.cta_url || "#";
+          go.target = "_blank";
+          go.rel = "noreferrer";
+          const close = document.createElement("button");
+          close.type = "button";
+          close.className = "rail-offer-close";
+          close.textContent = "✕";
+          close.title = "Dismiss";
+          close.onclick = () => { localStorage.setItem("vaultline.offer.dismissed", String(offer.id)); box.remove(); };
+          box.append(close, head, text, go);
+          card.after(box);
+        });
+      }
+    }).then(() => {
+      // Rendered last, and each self-guarded: neither the upload strip nor the
+      // disk-footprint fact may cost the card above them a single field.
+      railSyncUpload(api, bytes, card, state && state.upload);
+      return railDiskFact(api, bytes);
+    });
+  }).catch((error) => {
+    // The skeleton stays put on failure — placeholders are already honest
+    // ("—") — and the reason is kept for inspection rather than swallowed.
+    if (typeof window !== "undefined") window.__railError = String((error && error.message) || error);
+  });
+}
+
+// ---- Local footprint -------------------------------------------------------
+
+/**
+ * One more fact for the identity strip: how much session history is sitting on
+ * this disk. /v1/sessions walks every agent's directory — hundreds of files —
+ * so it is asked exactly once per page load, never from a poll, and a failure
+ * or an empty answer just leaves the list one line shorter.
+ */
+function railWriteDiskFact(text) {
+  const slot = document.getElementById("acct-disk-text");
+  if (slot) { slot.textContent = text; return true; }
+  // Older markup without the reserved row: append one, as before.
+  const storage = document.getElementById("acct-storage");
+  const list = storage && storage.parentElement;
+  if (!list || typeof list.append !== "function" || document.getElementById("acct-disk")) return false;
+  const item = document.createElement("li");
+  item.id = "acct-disk";
+  const dot = document.createElement("span");
+  dot.className = "dot";
+  const span = document.createElement("span");
+  span.className = "acct-fact-text";
+  span.textContent = text;
+  item.append(dot, span);
+  list.append(item);
+  return true;
+}
+
+/** The door renders into its reserved slot, once; re-renders just retarget the href. */
+function railPlaceDoor(card, panelUrl) {
+  let door = document.getElementById("acct-panel-link");
+  if (!door) {
+    door = document.createElement("a");
+    door.id = "acct-panel-link";
+    door.className = "action acct-door";
+    door.target = "_blank";
+    door.rel = "noreferrer";
+    door.textContent = "Cloud panel ↗";
+    const slot = document.getElementById("acct-door-slot");
+    if (slot) slot.append(door);
+    else if (card && typeof card.append === "function") card.append(door);
+  }
+  door.href = panelUrl;
+}
+
+let railDiskFactAsked = false;
+function railDiskFact(api, bytes) {
+  if (railDiskFactAsked) return;
+  railDiskFactAsked = true;
+  return api("/v1/sessions").catch(() => null).then((disk) => {
+    const total = disk == null ? NaN : Number(disk.totalBytes);
+    if (!Number.isFinite(total)) return;
+    const line = `${bytes(total)} of sessions on this disk`;
+    railWriteDiskFact(line);
+    // The slow fact joins the snapshot so the NEXT load paints it instantly.
+    try {
+      const prior = JSON.parse(sessionStorage.getItem("vaultline.railSnapshot") || "{}");
+      sessionStorage.setItem("vaultline.railSnapshot", JSON.stringify({ ...prior, diskText: line }));
+    } catch { /* snapshot is a convenience, never a requirement */ }
+  });
+}
+
+// ---- Upload progress in the rail -------------------------------------------
+
+/**
+ * While an upload run is active, every page's rail carries a compact strip of
+ * it — meter, counts, pace — so walking from the dashboard to Sessions or
+ * Retention never means losing sight of a send. The run lives on the server;
+ * this only watches: a 3-second poll that exists exclusively while a run is
+ * active and stops the moment it is not, so a page rendered with no run never
+ * starts a timer at all. The whole strip is a link back to the dashboard's
+ * Retention view, where the full progress and its cancel live.
+ */
+let railUploadTimer = null;
+let railUploadEls = null;
+
+/** Same honest edges as the dashboard's own pace line: no rate worth stating
+    before anything lands, then bytes-based so it converges as big files move. */
+function railUploadEta(run) {
+  const elapsed = (Date.now() - Date.parse(run.startedAt)) / 1000;
+  if (!(run.doneBytes > 0) || !Number.isFinite(elapsed)) return "measuring…";
+  const left = (run.totalBytes - run.doneBytes) / (run.doneBytes / Math.max(1, elapsed));
+  if (!Number.isFinite(left) || left < 0) return "measuring…";
+  const human = left < 90 ? `${Math.max(1, Math.round(left / 10) * 10)}s` : left < 5400 ? `${Math.round(left / 60)} min` : `${(left / 3600).toFixed(1)} h`;
+  return `~${human} left`;
+}
+
+function railDrawUpload(run, bytes) {
+  if (!railUploadEls) return;
+  const total = Number(run.totalBytes) || 0;
+  const done = Number(run.doneBytes) || 0;
+  const active = !run.finishedAt;
+  const pct = total > 0 ? Math.min(100, (done / total) * 100) : active ? 0 : 100;
+  railUploadEls.fill.style.width = `${pct.toFixed(1)}%`;
+  const sent = (run.done || []).length;
+  if (active) {
+    const tail = run.cancelled ? "stopping…" : railUploadEta(run);
+    railUploadEls.line.textContent = `↑ ${sent} of ${Number(run.totalCount) || 0} · ${bytes(done)} of ${bytes(total)} · ${tail}`;
+  } else {
+    const failed = run.failed || [];
+    const word = run.cancelled ? "Stopped" : "Done";
+    railUploadEls.line.textContent = failed.length
+      ? `${word} — ${sent} sent, ${failed.length} failed — ${failed[0].error}`
+      : `${word} — ${sent} sent, ${bytes(Number(run.freedBytes) || 0)} freed locally`;
+  }
+}
+
+function railStopUploadPoll() {
+  if (railUploadTimer) { clearInterval(railUploadTimer); railUploadTimer = null; }
+}
+
+function railRemoveUploadStrip() {
+  const strip = railUploadEls && railUploadEls.strip;
+  railUploadEls = null;
+  if (!strip) return;
+  if (typeof strip.remove === "function") strip.remove();
+  else strip.hidden = true;
+}
+
+/** Under the identity card — or under the offer box when one sits there. */
+function railInjectUploadStrip(card) {
+  if (document.getElementById("rail-upload")) return;
+  const anchor = document.getElementById("rail-offer") || card;
+  if (!anchor || typeof anchor.after !== "function") return;
+  const strip = document.createElement("a");
+  strip.id = "rail-upload";
+  strip.className = "rail-upload";
+  strip.href = "./index.html#archives";
+  strip.title = "Upload in progress — the full view, and its cancel, live on the dashboard's Retention tab";
+  const meter = document.createElement("div");
+  meter.className = "meter";
+  const fill = document.createElement("div");
+  fill.className = "meter-fill";
+  meter.append(fill);
+  const line = document.createElement("div");
+  line.className = "rail-upload-line";
+  strip.append(meter, line);
+  anchor.after(strip);
+  railUploadEls = { strip, fill, line, done: false };
+}
+
+function railSyncUpload(api, bytes, card, run) {
+  try {
+    const active = Boolean(run && !run.finishedAt);
+    if (!active) {
+      railStopUploadPoll();
+      if (!railUploadEls) return;
+      // A run that just finished gets its last word for this page view; a rail
+      // re-rendered after that — or with the run gone entirely — drops the strip.
+      if (run && run.finishedAt && !railUploadEls.done) {
+        railUploadEls.done = true;
+        railDrawUpload(run, bytes);
+      } else {
+        railRemoveUploadStrip();
+      }
+      return;
+    }
+    if (!railUploadEls) railInjectUploadStrip(card);
+    if (!railUploadEls) return; // nowhere to draw — nothing to watch either
+    railUploadEls.done = false;
+    railDrawUpload(run, bytes);
+    if (railUploadTimer) return;
+    railUploadTimer = setInterval(() => {
+      api("/v1/status")
+        .then((fresh) => railSyncUpload(api, bytes, card, fresh && fresh.upload))
+        .catch(() => { /* a missed poll is the next poll's problem */ });
+    }, 3000);
+  } catch { /* the strip is a garnish: no failure here may cost the rail */ }
+}

package/web/retention.html

@@ -0,0 +1,17 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>Free up disk — rules · Sealkeep</title>
+<meta name="referrer" content="no-referrer">
+</head>
+<body>
+<!-- The rules editor is a dashboard view now (index.html#rules) — one page,
+     no reloads between views. This stub keeps old bookmarks and links working,
+     preserving a #token=… fragment when one is carried. -->
+<script>
+  const h = location.hash.replace(/^#/, "");
+  location.replace(h.includes("token=") ? `./index.html#${h}` : "./index.html#rules");
+</script>
+</body>
+</html>

package/web/rules-view.js

@@ -0,0 +1,249 @@
+/**
+ * The Free up disk rules editor, as a dashboard view.
+ *
+ * This was retention.html, a page of its own — reached from the Free up disk
+ * tab and Settings, and every visit was a reload of the whole panel. Same
+ * fold as the Memory pool: the markup is a view in index.html, this is the
+ * page's script wrapped in one init, and `api`/`token` come from app.js.
+ *
+ * On re-entry it re-reads the rules and the stored copies so the form never
+ * quietly disagrees with a vault edited elsewhere — but the form is already
+ * on screen while that happens; nothing blanks.
+ */
+(() => {
+  const $ = (id) => document.getElementById(id);
+  const policy = () => document.querySelector('input[name=policy]:checked').value;
+
+  const MB = 1024 * 1024;
+
+  const bytes = (value) => {
+    if (!Number.isFinite(value) || value <= 0) return "0 B";
+    const units = ["B", "KB", "MB", "GB", "TB"];
+    let size = value, unit = 0;
+    while (size >= 1024 && unit < units.length - 1) { size /= 1024; unit += 1; }
+    return `${size < 10 && unit > 0 ? size.toFixed(1) : Math.round(size)} ${units[unit]}`;
+  };
+
+  /** Empty means "do not consider this rule" — which is not the same as zero. */
+  const optional = (id, scale = 1) => {
+    const raw = $(id).value.trim();
+    return raw === "" ? null : Math.max(0, Number(raw) || 0) * scale;
+  };
+
+  function render() {
+    const older = Math.max(0, Number($("older").value) || 0);
+    const grace = Math.max(0, Number($("grace").value) || 0);
+    const raw = $("deleteAfter").value.trim();
+    // Empty means never. "0" is a real answer and must not be swallowed by falsiness.
+    const deleteAfter = raw === "" ? "never" : String(Math.max(0, Number(raw) || 0));
+    const idle = optional("idle");
+    const minBytes = optional("minSize", MB);
+    $("out").textContent = `sealkeep retention policy --policy ${policy()} \\\n`
+      + `  --older-than-days ${older} --grace-days ${grace} \\\n`
+      + `  --delete-after-days ${deleteAfter} \\\n`
+      + `  --idle-days ${idle === null ? "off" : idle} --min-bytes ${minBytes === null ? "off" : minBytes}`;
+    $("saved").textContent = "";
+  }
+
+  /** What the rules currently mean, in the only unit that matters: disk. */
+  function showEffect(evaluation) {
+    const eligible = evaluation.candidates.filter((candidate) => candidate.eligible).length;
+    $("effect").textContent = eligible === 0
+      ? `Nothing is reclaimable under these rules right now — ${evaluation.candidates.length} archived session${evaluation.candidates.length === 1 ? " is" : "s are"} being tracked.`
+      : `${bytes(evaluation.reclaimableBytes)} across ${eligible} session${eligible === 1 ? "" : "s"} could be moved to your trash under these rules.`;
+  }
+
+  function fill(evaluation) {
+    const chosen = document.querySelector(`input[name=policy][value="${evaluation.policy}"]`);
+    if (chosen) chosen.checked = true;
+    $("older").value = evaluation.olderThanDays;
+    $("grace").value = evaluation.graceDays;
+    $("idle").value = evaluation.sourceIdleDays === null ? "" : evaluation.sourceIdleDays;
+    $("minSize").value = evaluation.minSourceBytes === null ? "" : Math.round(evaluation.minSourceBytes / MB);
+    $("deleteAfter").value = evaluation.deleteAfterDays == null ? "" : evaluation.deleteAfterDays;
+    render();
+    showEffect(evaluation);
+  }
+
+  // ---- Stored copies -------------------------------------------------------
+
+  const age = (iso) => {
+    if (!iso) return "—";
+    const days = Math.floor((Date.now() - Date.parse(iso)) / 86400000);
+    if (!Number.isFinite(days) || days < 0) return "—";
+    return days === 0 ? "today" : days === 1 ? "1 day" : `${days} days`;
+  };
+
+  function copyRow(copy) {
+    const row = document.createElement("tr");
+    const ref = document.createElement("td");
+    ref.className = "path";
+    ref.textContent = copy.ref;
+    if (copy.lastCopy) {
+      const mark = document.createElement("span");
+      mark.className = "lastmark";
+      mark.title = "This machine no longer holds these bytes, so this stored copy is the only one.";
+      mark.textContent = "last copy";
+      ref.append(mark);
+    }
+    const size = document.createElement("td");
+    size.className = "num";
+    size.textContent = bytes(copy.bytes);
+    const when = document.createElement("td");
+    when.className = "num";
+    when.textContent = age(copy.addedAt);
+    const cell = document.createElement("td");
+    const button = document.createElement("button");
+    button.type = "button";
+    button.className = "action danger del";
+    button.textContent = "Delete";
+    const message = document.createElement("span");
+    message.className = "rowmsg";
+    button.addEventListener("click", () => deleteCopy(copy, button, message));
+    cell.append(button, message);
+    row.append(ref, size, when, cell);
+    return row;
+  }
+
+  async function deleteCopy(copy, button, message) {
+    // The design system's destructive pattern: the first click arms, the second
+    // acts, and an armed button left alone stands down after four seconds so
+    // nothing stays one click from deletion.
+    const restLabel = () => (button.dataset.last === "yes" ? "Delete anyway" : "Delete");
+    if (button.dataset.armed !== "yes") {
+      button.dataset.armed = "yes";
+      button.textContent = "Confirm";
+      setTimeout(() => {
+        if (button.dataset.armed === "yes") { button.dataset.armed = "no"; button.textContent = restLabel(); }
+      }, 4000);
+      return;
+    }
+    button.dataset.armed = "no";
+    button.disabled = true;
+    message.textContent = "";
+    try {
+      await api(`/v1/cloud/copies/${encodeURIComponent(copy.ref)}`, {
+        method: "DELETE",
+        body: JSON.stringify({ confirmLastCopy: button.dataset.last === "yes" })
+      });
+      await loadCopies();
+    } catch (error) {
+      button.disabled = false;
+      if (error.lastCopy) {
+        // The server stopped short. Say what would be lost, what has not been,
+        // and both ways forward — then make deleting take the two steps again.
+        button.dataset.last = "yes";
+        button.textContent = "Delete anyway";
+        message.textContent = "This is the only copy left anywhere — nothing has been deleted. Restore the archive to get a local copy back first, or delete it knowing the archive is then gone for good.";
+      } else {
+        button.textContent = restLabel();
+        message.textContent = `Not deleted: ${error.message}`;
+      }
+    }
+  }
+
+  async function loadCopies() {
+    let data;
+    try {
+      data = await api("/v1/cloud/copies");
+    } catch (error) {
+      $("copies-line").textContent = token
+        ? `Could not read your stored copies: ${error.message}`
+        : "Connect the dashboard to see what is stored off this machine.";
+      return;
+    }
+    const { copies, mode } = data;
+    if (mode === "none") {
+      $("copies-line").textContent = "No storage is connected to this vault, so nothing is stored off this machine. Everything you have archived lives here only.";
+      $("copies-table").hidden = true;
+      return;
+    }
+    const total = copies.reduce((sum, copy) => sum + copy.bytes, 0);
+    $("copies-line").textContent = copies.length === 0
+      ? "Nothing is stored off this machine yet."
+      : `${copies.length} ${copies.length === 1 ? "copy" : "copies"} · ${bytes(total)} in your storage.`;
+    const body = $("copies-body");
+    body.textContent = "";
+    for (const copy of copies) body.append(copyRow(copy));
+    $("copies-table").hidden = copies.length === 0;
+    if ($("cap") !== document.activeElement) $("cap").value = data.rollingCapGb == null ? "" : data.rollingCapGb;
+  }
+
+  function loadRules() {
+    // Show what is actually configured rather than the markup's defaults, so
+    // this view never quietly disagrees with the vault it is editing.
+    api("/v1/retention").then(fill).catch((error) => {
+      $("effect").textContent = token
+        ? `Could not read the current rules: ${error.message}`
+        : "Connect the dashboard so it can read this vault's current rules.";
+    });
+  }
+
+  function wire() {
+    $("save").onclick = async () => {
+      $("save").disabled = true;
+      $("saved").textContent = "Saving…";
+      try {
+        const evaluation = await api("/v1/retention/policy", {
+          method: "PUT",
+          body: JSON.stringify({
+            policy: policy(),
+            olderThanDays: Math.max(0, Number($("older").value) || 0),
+            graceDays: Math.max(0, Number($("grace").value) || 0),
+            sourceIdleDays: optional("idle"),
+            minSourceBytes: optional("minSize", MB),
+            // Was collected, rendered into the command preview, and never sent —
+            // so the page said "Saved" about a rule for deleting archives that it
+            // had quietly dropped.
+            deleteAfterDays: optional("deleteAfter")
+          })
+        });
+        showEffect(evaluation);
+        $("saved").textContent = "Saved. The background service uses these from its next pass.";
+      } catch (error) {
+        $("saved").textContent = `Not saved: ${error.message}`;
+      } finally {
+        $("save").disabled = false;
+      }
+    };
+
+    for (const input of document.querySelectorAll('input[name=policy]')) input.addEventListener("change", render);
+    for (const id of ["older", "grace", "deleteAfter", "idle", "minSize"]) $(id).addEventListener("input", render);
+
+    // The rolling cap is a Pro setting: the account is what enforces it, so a
+    // vault without that account has nowhere real to write it.
+    api("/v1/status").then((status) => { if (status.plan === "pro") $("rolling").hidden = false; }).catch(() => {});
+
+    $("cap-save").onclick = async () => {
+      const raw = $("cap").value.trim();
+      const capGb = raw === "" ? null : Number(raw);
+      if (capGb !== null && (!Number.isFinite(capGb) || capGb < 1)) {
+        $("cap-msg").textContent = "The cap must be at least 1 GB — or leave it empty to keep every copy.";
+        return;
+      }
+      $("cap-save").disabled = true;
+      $("cap-msg").textContent = "Saving…";
+      try {
+        await api("/v1/cloud/rolling", { method: "PUT", body: JSON.stringify({ capGb }) });
+        $("cap-msg").textContent = capGb === null
+          ? "No cap — every stored copy is kept."
+          : `Saved. Your storage trims to the newest ${capGb} GB within a day; nothing on this machine changes.`;
+      } catch (error) {
+        $("cap-msg").textContent = `Not saved: ${error.message}`;
+      } finally {
+        $("cap-save").disabled = false;
+      }
+    };
+  }
+
+  let initialised = false;
+  window.initRulesView = function () {
+    if (!initialised) {
+      initialised = true;
+      wire();
+      render();
+    }
+    void loadCopies();
+    loadRules();
+  };
+})();