samagotchi 0.57.0 → 0.59.0

data/lib/samagotchi/web/public/refs.js

@@ -2,16 +2,24 @@
 // a kind and a target: today a file tool's row title (the server's FileRef,
 // {kind: "file", path, line?, end_line?}), that row's diff lines and a
 // read row's numbered lines (the same file at a line), and an edit/write
-// approval card's paths and its dry run's diff lines. The DOM carries data-ref-kind and the target's
-// attributes, never what a click does: that is an action, kept per kind in
-// REF_ACTIONS, and a click runs the first one available to this viewer. A
-// ref with none (a phone: no editor) stays plain text; the page marks the
-// kinds that have one on its body (refs-<kind>), which the hover styling
-// keys on.
+// approval card's paths and its dry run's diff lines, and a `path:line` in
+// an answer or a step's text (ref_scan.js; a link whose text is one too).
+// The DOM carries data-ref-kind and the target's attributes, never what a
+// click does: those are the ref's targets, kept per kind in REF_ACTIONS.
+// A plain click runs the first one available (the main target); a ref
+// with more shows a ▾ on hover that opens a menu of all of them
+// (ref_menu.js), and a tap opens it. A ref with a target is a tab stop
+// (syncRefTabs): Enter is its click, ↓ its menu. A ref with none (a phone's row title:
+// no editor, and the row is the ref's own) stays plain text; refs.js marks
+// a hovered or focused ref with its main target (data-ref-main), which the
+// hover styling keys on.
 
 import { escapeHtml } from "./format.js";
+import { copyText } from "./copy.js";
+import { createRefMenu } from "./ref_menu.js";
 
-// The data attributes a ref's element carries.
+// The data attributes a ref's element carries (its tab stop comes from
+// syncRefTabs, for the viewer).
 export function refAttrs(ref) {
   if (!ref?.kind) return "";
   const attr = (name, value) => (value ? ` data-ref-${name}="${escapeHtml(String(value))}"` : "");
@@ -27,29 +35,59 @@ export function editorUrl(template, path, line) {
   return template.replaceAll("{path}", encoded).replaceAll("{line}", String(line || 1));
 }
 
-// What a ref can do, per kind, in order: the first available one is a
-// click's. +viewer+ is what this page's viewer can do ({editor, editorUrl}:
-// the server's capabilities.editor and editor_url).
+// A ref's targets, per kind, in order: the first available one is a plain
+// click's (the main target), all of them are the menu's. Each says when
+// it's available for +viewer+ (what this page's viewer can do: {editor,
+// editorUrl}, the server's capabilities.editor and editor_url) and
+// +target+ (refTarget's). A secondary one (copy) joins a ref that has
+// another, never alone. A line (a diff or read line) has its click only.
 export const REF_ACTIONS = Object.freeze({
   file: Object.freeze([
+    // A link whose text is the ref (github-pr's PR diff): its href stays
+    // the plain click's, which the browser follows.
+    Object.freeze({
+      id: "link",
+      label: (target) => (/\/pull\/\d+\/files\b/.test(target.href) ? "PR diff" : "Open link"),
+      available: (_viewer, target) => !!target.href,
+      run: (target, _viewer, env) => env.openLink(target.href),
+    }),
     Object.freeze({
       id: "editor",
+      label: () => "Open in editor",
       available: (viewer) => viewer?.editor === true && !!viewer.editorUrl,
       url: (target, viewer) => editorUrl(viewer.editorUrl, target.path, target.line),
+      run(target, viewer, env) {
+        const url = this.url(target, viewer);
+        if (url) env.open(url);
+      },
       // The hover hint: it opens the file as it is now.
       hint: (target) => `Open the current file in your editor${target.line ? ` at line ${target.line}` : ""}`,
     }),
+    // The row that touched the file, in the turn: not for a row's own
+    // title or lines (they are in the turn already).
+    Object.freeze({
+      id: "show",
+      label: () => "Show in turn",
+      available: (_viewer, target) => !target.isLine && !target.owner?.matches?.(".activity-row") && !!turnRowFor(target),
+      run: (target, _viewer, env) => env.show(target),
+      hint: () => "Show the row that touched it in the turn",
+    }),
+    Object.freeze({
+      id: "copy",
+      label: () => "Copy path",
+      secondary: true,
+      available: (_viewer, target) => !target.isLine && !!target.path,
+      run: (target, _viewer, env) => env.copy(target.path),
+    }),
   ]),
 });
 
-// The first action +viewer+ has for a ref of +kind+, else null.
-export function refAction(kind, viewer, actions = REF_ACTIONS) {
-  return (actions[kind] || []).find((action) => action.available(viewer)) || null;
-}
-
-// The kinds that have an action for +viewer+ (the page's refs-<kind> classes).
-export function availableKinds(viewer, actions = REF_ACTIONS) {
-  return Object.keys(actions).filter((kind) => refAction(kind, viewer, actions));
+// The targets +viewer+ has for +target+ (refTarget's), in order; none
+// when only a secondary one is.
+export function refActions(target, viewer, actions = REF_ACTIONS) {
+  if (!target) return [];
+  const found = (actions[target.kind] || []).filter((action) => action.available(viewer, target));
+  return found.some((action) => !action.secondary) ? found : [];
 }
 
 // What owns a ref and its diff lines: a tool row, or an edit's approval
@@ -59,23 +97,25 @@ const OWNERS = ".activity-row, .bubble.approval";
 // A line of the owner's file: a diff line, or a read row's numbered line.
 const LINES = ".diff-line[data-line], .read-line[data-line]";
 
-// What a click on +el+ points at: {kind, path, line, owner} or null. A row
-// title (or an approval card's path) opens its file at the lines the call
-// named (an edit without any at its first changed line); a diff line (or a
-// hunk header) or a read row's numbered line, in a row or a card with a
-// ref, opens that file at that line.
+// What a click on +el+ points at: {kind, path, line, owner, el, isLine,
+// href} or null. A row title (or an approval card's path) opens its file
+// at the lines the call named (an edit without any at its first changed
+// line); a diff line (or a hunk header) or a read row's numbered line, in
+// a row or a card with a ref, opens that file at that line. +el+ is the
+// ref's element (the line for a line), +href+ a link ref's.
 // A diff line elsewhere is none.
 export function refTarget(el) {
   const title = el?.closest?.("[data-ref-kind]");
   if (title) {
     const owner = title.closest(OWNERS);
-    return { ...targetOf(title), line: Number(title.dataset.refLine) || firstChange(owner), owner: owner || title };
+    const href = title.matches("a[href]") ? title.getAttribute("href") : null;
+    return { ...targetOf(title), line: Number(title.dataset.refLine) || firstChange(owner), owner: owner || title, el: title, isLine: false, href };
   }
   const diffLine = el?.closest?.(LINES);
   const owner = diffLine?.closest(OWNERS);
   const ref = owner?.querySelector("[data-ref-kind]");
   if (!ref) return null;
-  return { ...targetOf(ref), line: Number(diffLine.dataset.line), owner };
+  return { ...targetOf(ref), line: Number(diffLine.dataset.line), owner, el: diffLine, isLine: true, href: null };
 }
 
 function targetOf(el) {
@@ -89,6 +129,99 @@ function firstChange(row) {
   return line ? Number(line.dataset.line) : null;
 }
 
+// The tool row that touched +target+'s file, for "show in turn", or null:
+// a row with a ref to the same file that isn't the ref's own. Looked for
+// in the ref's own step (a step's text comes before its rows), then its
+// own turn (turnBlockOf), then the rows before it, then the nearest after
+// it; in the first of those that has any, the last one showing the ref's
+// line, else the last one (after it: the nearest).
+export function turnRowFor(target) {
+  const el = target?.el;
+  if (!el?.ownerDocument || !target.path) return null;
+  const rows = [...el.ownerDocument.querySelectorAll(".activity-row")].filter((row) => {
+    if (row.contains(el)) return false;
+    const ref = row.querySelector("[data-ref-kind]");
+    return ref?.dataset.refKind === target.kind && ref.dataset.refPath === target.path;
+  });
+  const step = el.closest("details.gen");
+  const turn = turnBlockOf(el);
+  const before = rows.filter((row) => precedes(row, el));
+  const pools = [
+    step ? rows.filter((row) => step.contains(row)) : [],
+    turn ? rows.filter((row) => turn.contains(row)) : [],
+    before,
+    rows.filter((row) => !before.includes(row)).reverse(),
+  ];
+  const pool = pools.find((found) => found.length);
+  if (!pool) return null;
+  const showing = target.line ? pool.filter((row) => lineIn(row, target.line)) : [];
+  return showing.at(-1) || pool.at(-1);
+}
+
+// What holds +el+'s turn's rows: the steps block it is in, the stage (a
+// live turn: its answer comes before its cloud), else the nearest steps
+// block before it with no prompt between them (an answer, a card, in the
+// history). null when there is none.
+function turnBlockOf(el) {
+  const own = el.closest(".turn-work, .turn-stage");
+  if (own) return own;
+  const doc = el.ownerDocument;
+  const block = [...doc.querySelectorAll(".turn-work")].filter((b) => precedes(b, el)).at(-1);
+  if (!block) return null;
+  const prompt = [...doc.querySelectorAll(".bubble.user")].some((u) => precedes(block, u) && precedes(u, el));
+  return prompt ? null : block;
+}
+
+// +a+ comes before +b+ in the page (and doesn't hold it).
+function precedes(a, b) {
+  return !a.contains(b) && !!(a.compareDocumentPosition(b) & 4 /* Node.DOCUMENT_POSITION_FOLLOWING */);
+}
+
+// +row+'s line +line+: an added or context diff line first (a removed one
+// shares its number), then a read line; null when it doesn't show it.
+function lineIn(row, line) {
+  for (const selector of [".diff-line.diff-add", ".diff-line.diff-ctx", ".read-line", ".diff-line"]) {
+    const found = row.querySelector(`${selector}[data-line="${Number(line)}"]`);
+    if (found) return found;
+  }
+  return null;
+}
+
+// "Show in turn": opens what hides the row that touched +target+'s file
+// (the turn's steps, its step), its diff (or the read that shows the
+// line), scrolls to the line (else the row) and flashes both. A view that
+// hides its rows its own way (the stage's cloud) opens on the row's
+// ref:reveal event, which bubbles. The row, or null when there is none.
+export function showInTurn(target, { behavior = smoothScroll() } = {}) {
+  const row = turnRowFor(target);
+  if (!row) return null;
+  const view = row.ownerDocument.defaultView || globalThis;
+  row.dispatchEvent(new view.CustomEvent("ref:reveal", { bubbles: true }));
+  const line = target.line ? lineIn(row, target.line) : null;
+  const fold = line?.closest("details.activity-diff, details.activity-read") || row.querySelector("details.activity-diff");
+  for (let details = (line || fold || row).closest("details"); details; details = details.parentElement?.closest("details")) {
+    details.open = true;
+  }
+  if (fold) fold.open = true;
+  (line || row).scrollIntoView?.({ block: "center", behavior });
+  for (const el of [row, line].filter(Boolean)) flash(el);
+  return row;
+}
+
+const FLASH_MS = 1600;
+
+function flash(el) {
+  el.classList.remove("ref-flash");
+  void el.offsetWidth; // restarts the animation on a second show
+  el.classList.add("ref-flash");
+  clearTimeout(el._refFlash);
+  el._refFlash = setTimeout(() => el.classList.remove("ref-flash"), FLASH_MS);
+}
+
+function smoothScroll() {
+  return globalThis.matchMedia?.("(prefers-reduced-motion: reduce)").matches ? "auto" : "smooth";
+}
+
 // A drag that selected text in the clicked ref's row isn't a click on the
 // ref. A selection elsewhere on the page (or a collapsed one) doesn't count.
 function selectingIn(owner, selection) {
@@ -102,42 +235,129 @@ function defaultOpen(url) {
   else window.location.href = url;
 }
 
-// One delegated listener on +root+ for every ref on the page. +viewer+()
-// is read per click and hover, so a capabilities change (another session,
-// a reload) is seen; +open+(url) opens an action's URL.
-export function installRefClicks(root, viewer, { open = defaultOpen, selection = () => window.getSelection?.() } = {}) {
+// A link ref's href from the menu: a new tab, as the answer's links open.
+function defaultOpenLink(href) {
+  window.open(href, "_blank", "noopener");
+}
+
+// One delegated listener set on +root+ for every ref on the page.
+// +viewer+() is read per click, key and hover, so a capabilities change
+// (another session, a reload) is seen. The targets run through: +open+(url)
+// (the editor's URL), +openLink+(href), +show+(target) and +copy+(text).
+// +menu+ is the ▾ and its menu (ref_menu.js).
+export function installRefClicks(root, viewer, {
+  open = defaultOpen, openLink = defaultOpenLink, show = (target) => showInTurn(target), copy = copyText,
+  selection = () => window.getSelection?.(), menu = createRefMenu(root.ownerDocument),
+} = {}) {
+  const env = { open, openLink, show, copy };
+  const run = (action, target) => action.run(target, viewer(), env);
+  const items = (actions, target) => actions.map((action) => ({ id: action.id, label: action.label(target), run: () => run(action, target) }));
+  const openMenu = (target, actions, options) => menu.open(target.el, items(actions, target), options);
+  // The last pointer's type: a tap opens the menu, a mouse click runs the
+  // main target.
+  let pointer = "mouse";
+  root.addEventListener("pointerdown", (e) => { pointer = e.pointerType || "mouse"; }, true);
+  // A key press: the keyboard leads now (Enter on a link after a tap is
+  // the link's own click); Tab works out the tab stops before it moves.
+  root.addEventListener("keydown", (e) => {
+    pointer = "keyboard";
+    if (e.key === "Tab") syncRefTabs(root, viewer());
+  }, true);
+
   root.addEventListener("click", (e) => {
     if (e.button !== 0 || e.defaultPrevented) return;
     const target = refTarget(e.target);
     if (!target) return;
-    const action = refAction(target.kind, viewer());
-    if (!action) return;
+    const actions = refActions(target, viewer());
+    if (!actions.length) return;
     if (selectingIn(target.owner, selection())) return;
-    const url = action.url(target, viewer());
-    if (!url) return;
+    if (pointer === "touch" && !target.isLine && actions.length > 1) {
+      e.preventDefault();
+      e.stopPropagation();
+      openMenu(target, actions, { focus: false });
+      return;
+    }
+    // A link's own click: the browser follows it.
+    if (actions[0].id === "link") return;
     e.preventDefault();
     e.stopPropagation();
-    open(url);
+    run(actions[0], target);
   });
-  // The hover hint, on the ref's own element, worked out on each hover
-  // (the viewer can change): its own title (a row title's hover) first,
-  // then the action's hint when there is one.
-  root.addEventListener("mouseover", (e) => {
+
+  // A focused ref: Enter is its main target (a link's Enter is its own
+  // click), ↓ opens the menu with the first target focused, Esc hides the ▾.
+  root.addEventListener("keydown", (e) => {
+    if (e.altKey || e.ctrlKey || e.metaKey || e.shiftKey) return;
+    const el = e.target;
+    if (!el?.matches?.("[data-ref-kind]")) return;
+    if (e.key === "Escape") menu.hideMore();
+    if (e.key !== "Enter" && e.key !== "ArrowDown") return;
+    const target = refTarget(el);
+    const actions = refActions(target, viewer());
+    if (!actions.length) return;
+    if (e.key === "Enter") {
+      if (actions[0].id === "link") return;
+      e.preventDefault();
+      run(actions[0], target);
+    } else if (actions.length > 1) {
+      e.preventDefault();
+      openMenu(target, actions, { focus: true });
+    }
+  });
+
+  // On hover or focus: the ref's main target on it (data-ref-main, for the
+  // styling), its hover hint, and the ▾ when it has more than one (not
+  // after a tap, which opens the menu itself).
+  const mark = (e) => {
     const target = refTarget(e.target);
     if (!target) return;
-    const el = e.target.closest("[data-ref-kind]") || e.target.closest(LINES);
-    if (!el) return;
-    if (el.dataset.refTitle === undefined) el.dataset.refTitle = el.getAttribute("title") || "";
-    const own = el.dataset.refTitle;
-    const action = refAction(target.kind, viewer());
-    const title = [own, action ? action.hint(target) : ""].filter(Boolean).join("\n");
-    if (title) el.setAttribute("title", title);
-    else el.removeAttribute("title");
-  });
+    const actions = refActions(target, viewer());
+    const el = target.el;
+    if (actions.length) el.dataset.refMain = actions[0].id;
+    else delete el.dataset.refMain;
+    if (!target.isLine) setRefRole(el, actions);
+    hint(el, target, actions[0]);
+    if (!target.isLine && actions.length > 1 && pointer !== "touch") menu.showMore(el, () => openMenu(refTarget(el), refActions(refTarget(el), viewer()), { focus: true }));
+  };
+  root.addEventListener("mouseover", mark);
+  root.addEventListener("focusin", mark);
+  const leave = (e) => {
+    const el = e.target?.closest?.("[data-ref-kind]");
+    if (el && !el.contains(e.relatedTarget)) menu.hideMoreSoon(el);
+  };
+  root.addEventListener("mouseout", leave);
+  root.addEventListener("focusout", leave);
+}
+
+// The tab stops under +root+ for +viewer+: a ref is one (a button, with
+// aria-haspopup when it has a menu) only while it has a target, so a
+// phone's or an editorless viewer's row titles aren't. Worked out before a
+// Tab moves the focus and on a ref's hover or focus; a line never is one.
+export function syncRefTabs(root, viewer) {
+  for (const el of root.querySelectorAll("[data-ref-kind]")) setRefRole(el, refActions(refTarget(el), viewer));
+}
+
+function setRefRole(el, actions) {
+  if (actions.length > 1) el.setAttribute("aria-haspopup", "menu");
+  else el.removeAttribute("aria-haspopup");
+  // A link is focusable and a link already.
+  if (el.matches("a[href]")) return;
+  if (actions.length) {
+    el.tabIndex = 0;
+    el.setAttribute("role", "button");
+  } else {
+    el.removeAttribute("tabindex");
+    el.removeAttribute("role");
+  }
 }
 
-// The body's classes for +viewer+: refs-<kind> for each kind with an action.
-export function setRefKinds(body, viewer, actions = REF_ACTIONS) {
-  const kinds = availableKinds(viewer, actions);
-  for (const kind of Object.keys(actions)) body.classList.toggle(`refs-${kind}`, kinds.includes(kind));
+// The hover hint, on the ref's own element, worked out on each hover (the
+// viewer can change): its own title (a row title's hover) first, then the
+// main target's hint when it has one.
+function hint(el, target, action) {
+  if (el.dataset.refTitle === undefined) el.dataset.refTitle = el.getAttribute("title") || "";
+  const own = el.dataset.refTitle;
+  const title = [own, action?.hint ? action.hint(target) : ""].filter(Boolean).join("\n");
+  if (title) el.setAttribute("title", title);
+  else el.removeAttribute("title");
 }

data/lib/samagotchi/web/public/stage_view.js

@@ -106,6 +106,8 @@ export function createStageView({ historyEl, appendToHistory, isNearBottom: hist
   let flash = null; // { kind, text, until } a notice or nudge in the trail
   let collapsed = readCollapsed();
   let cloudOpen = false;
+  // A ref's "show in turn" opened a collapsed stage (not kept).
+  let revealed = false;
   let rafPending = false;
   let foldTimer = null;
   let watchTimer = null;
@@ -326,6 +328,7 @@ export function createStageView({ historyEl, appendToHistory, isNearBottom: hist
 
   function setCollapsed(value) {
     collapsed = value;
+    revealed = false;
     try { localStorage.setItem(COLLAPSE_KEY, value ? "1" : "0"); } catch (_) {}
     applyCollapsed();
   }
@@ -370,6 +373,19 @@ export function createStageView({ historyEl, appendToHistory, isNearBottom: hist
     else setCloud(!cloudOpen);
   });
   headline.addEventListener("click", peek);
+  // A ref's "show in turn" (refs.js) names a row in the cloud: open the
+  // stage and the cloud to it, as a hand toggle would.
+  // A collapsed stage opens for this turn only: the kept choice
+  // (chi_stage_collapsed) is left alone and comes back at the release.
+  stage.addEventListener("ref:reveal", (e) => {
+    if (!cloudBody.contains(e.target)) return;
+    if (collapsed) {
+      collapsed = false;
+      revealed = true;
+      applyCollapsed();
+    }
+    setCloud(true);
+  });
   headline.addEventListener("keydown", (e) => {
     if (e.key === "Enter" || e.key === " ") {
       e.preventDefault();
@@ -491,6 +507,11 @@ export function createStageView({ historyEl, appendToHistory, isNearBottom: hist
     settled = true;
     view.reset();
     emptySlots();
+    if (revealed) {
+      revealed = false;
+      collapsed = readCollapsed();
+      applyCollapsed();
+    }
   }
 
   // Everything the stage holds, into the history's end in the turn view's

data/lib/samagotchi/web/public/task_stop.js

@@ -22,10 +22,30 @@ export function stopTarget(row, features) {
 // A task_wait row's title without its wait ("npm test · up to 600s").
 const WAIT_SUFFIX = / · up to \d+s$/;
 
-// The command a task_create of this turn started +taskId+ with (its row's
-// view), else a task_wait row's title for it (the server titles one by its
-// task's command, also for a task from an earlier turn: ToolActivity.
-// task_title), or null.
+// The first line of an execute that was still running at its limit and
+// went on as a task (Tools::Execute::HANDED_OVER), then its task_id line.
+// Anchored at the start, an optional "ran as: …" line and "[execute]" lead
+// before it: a "task_id:" line anywhere else is the command's own output.
+// The twin of TaskRuntime.handed_over_id.
+const HANDED_OVER = /^(?:ran as: [^\n]*\n)?(?:\[execute\]\n)?Still running at the \d+s limit:[^\n]*\ntask_id: (\S+)/;
+
+// The task id an execute row's output hands over, else null.
+export function handedOverId(output) {
+  return HANDED_OVER.exec(output || "")?.[1] || null;
+}
+
+// The task id a row of this turn started: a task_create's, or an execute's
+// hand-over (handedOverId); else null.
+function startedId(row) {
+  if (row.tool === "execute") return handedOverId(row.output);
+  if (row.tool !== "task_create") return null;
+  return /(?:^|\n)task_id: (\S+)/.exec(row.output || "")?.[1] || null;
+}
+
+// The command a task_create or a handed-over execute of this turn started
+// +taskId+ with (its row's view), else a task_wait row's title for it (the
+// server titles one by its task's command, also for a task from an earlier
+// turn: ToolActivity.task_title), or null.
 export function taskCommand(gens, taskId) {
   let titled = null;
   for (const gen of gens || []) {
@@ -33,9 +53,7 @@ export function taskCommand(gens, taskId) {
       if (row.tool === "task_wait" && row.view?.task_id === taskId && row.title) {
         titled ||= row.title.replace(WAIT_SUFFIX, "");
       }
-      if (row.tool !== "task_create") continue;
-      const id = /(?:^|\n)task_id: (\S+)/.exec(row.output || "")?.[1];
-      if (id === taskId) return row.view?.command || null;
+      if (startedId(row) === taskId) return row.view?.command || null;
     }
   }
   return titled;

data/lib/samagotchi/worker.rb

@@ -219,8 +219,8 @@ module Samagotchi
                                      @bridge.queue_command(line, client_id: client_id, after_file: after_file)
                                    })
       # /model's default is the config's, as in the REPL; the Engine started
-      # on the session's model.
-      @default_model = ModelProfile.required_model_name(nil)
+      # on the session's model.  nil when there is no default.model.
+      @default_model = ModelProfile.default_model_name
       @commands = SessionCommands.new(engine: @engine, turn_flow: @turn_flow,
                                       default_model: @default_model, registry: @engine.command_registry,
                                       save: ->(session) { session.save(state_dir: @state_dir) })

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.57.0
+  version: 0.59.0
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -430,6 +430,7 @@ files:
 - lib/samagotchi/setting_explained.rb
 - lib/samagotchi/steer.rb
 - lib/samagotchi/steer_cut.rb
+- lib/samagotchi/steer_cut_after.rb
 - lib/samagotchi/system_prompt.rb
 - lib/samagotchi/terminal_ui.rb
 - lib/samagotchi/terminal_ui/attach_launcher.rb
@@ -562,6 +563,7 @@ files:
 - lib/samagotchi/web/public/question_cards.js
 - lib/samagotchi/web/public/read_view.js
 - lib/samagotchi/web/public/reasoning_history_chip.js
+- lib/samagotchi/web/public/ref_menu.js
 - lib/samagotchi/web/public/ref_scan.js
 - lib/samagotchi/web/public/refs.js
 - lib/samagotchi/web/public/restore.js