@abot-ai/runtime 1.3.1 → 1.5.0

package/dist/src/web-ui/app/components/passive-learning/knowledge-view.js

@@ -0,0 +1,137 @@
+import { escapeAttribute, escapeHtml } from "../../lib/text-format.js";
+import { learningTimeLabel } from "./presentation.js";
+
+const pageSize = 20;
+const views = new WeakMap();
+
+export function learningKnowledgeMarkup() {
+  return `<div class="co-worker-knowledge" data-learning-knowledge>
+    <section class="co-worker-knowledge-column" aria-label="Candidates">
+      <div class="co-worker-knowledge-heading"><div><h4>Candidates <span data-learning-candidate-count></span></h4>
+        <p>Patterns from conversations and computer activity.</p></div><span data-learning-threshold></span></div>
+      <p class="co-worker-knowledge-note" data-learning-candidate-note role="status" hidden></p>
+      <div class="co-worker-knowledge-list" data-learning-candidates></div>
+      <p class="co-worker-knowledge-note">Not used as memory yet. Promotion also requires two independent reinforcements. Scores are model judgments, not probabilities.</p>
+      <nav class="co-worker-knowledge-pagination" data-learning-pagination aria-label="Candidate pages" hidden>
+        <button type="button" data-learning-knowledge-page="previous" aria-label="Previous candidates">Previous</button>
+        <span data-learning-page-summary aria-live="polite"></span>
+        <button type="button" data-learning-knowledge-page="next" aria-label="Next candidates">Next</button>
+      </nav>
+    </section>
+    <section class="co-worker-knowledge-column" aria-label="Established memory">
+      <div class="co-worker-knowledge-heading"><div><h4>Established memory</h4>
+        <p>Recent memories <span data-learning-saved-count></span></p></div>
+        <button type="button" data-learning-memories>Manage memories</button></div>
+      <div class="co-worker-knowledge-list" data-learning-saved></div>
+      <p class="co-worker-knowledge-note" data-learning-history-note>Recent context from your activity. Manage memories opens the full list.</p>
+    </section>
+  </div>`;
+}
+
+export function renderLearningKnowledge(root, snapshot) {
+  const host = root.querySelector("[data-learning-knowledge]");
+  if (!host) return;
+  let view = views.get(root);
+  if (!view || view.host !== host || view.environmentId !== snapshot.environmentId) {
+    view = { host, page: 0, environmentId: snapshot.environmentId };
+    views.set(root, view);
+  }
+  view.snapshot = snapshot;
+  renderCandidates(view);
+  renderMemories(view);
+}
+
+export function handleKnowledgeClick(root, event) {
+  const button = event.target.closest?.("button[data-learning-knowledge-page]");
+  const view = views.get(root);
+  if (!button || !view || !view.host.contains(button) || button.disabled) return false;
+  const direction = button.dataset.learningKnowledgePage;
+  if (direction !== "previous" && direction !== "next") return false;
+  event.preventDefault();
+  view.page += direction === "next" ? 1 : -1;
+  renderCandidates(view);
+  return true;
+}
+
+function renderCandidates(view) {
+  const { host, snapshot } = view;
+  const candidates = Array.isArray(snapshot.candidates) ? snapshot.candidates : [];
+  view.page = Math.max(0, Math.min(view.page, Math.ceil(candidates.length / pageSize) - 1));
+  const offset = view.page * pageSize;
+  const threshold = boundedScore(snapshot.status?.preferences?.maturation?.promotionScore) ?? 90;
+  setText(host, "[data-learning-threshold]", `Promote at ${threshold}`);
+  setText(host, "[data-learning-candidate-count]", String(candidates.length));
+  const note = snapshot.candidateError ? `Candidates could not be refreshed: ${snapshot.candidateError}` : "";
+  setText(host, "[data-learning-candidate-note]", note);
+  host.querySelector("[data-learning-candidate-note]").hidden = !note;
+  const empty = snapshot.loadingCandidates ? "Loading candidates…"
+    : snapshot.candidateError ? "Candidates are unavailable. Refresh to try again."
+      : "No candidates yet. Useful patterns will appear here as ABot learns.";
+  const markup = candidates.length ? candidates.slice(offset, offset + pageSize).map(candidateMarkup).join("")
+    : `<p class="co-worker-knowledge-empty">${escapeHtml(empty)}</p>`;
+  replaceList(view, "candidateMarkup", "[data-learning-candidates]", markup);
+  host.querySelector("[data-learning-pagination]").hidden = candidates.length <= pageSize;
+  setText(host, "[data-learning-page-summary]", candidates.length
+    ? `${offset + 1}–${Math.min(offset + pageSize, candidates.length)} of ${candidates.length}` : "");
+  host.querySelector('[data-learning-knowledge-page="previous"]').disabled = view.page === 0;
+  host.querySelector('[data-learning-knowledge-page="next"]').disabled = offset + pageSize >= candidates.length;
+}
+
+function renderMemories(view) {
+  const { snapshot, host } = view;
+  const memories = Array.isArray(snapshot.status?.recentMemories) ? snapshot.status.recentMemories : [];
+  setText(host, "[data-learning-saved-count]", memories.length ? String(memories.length) : "");
+  const empty = !snapshot.status ? snapshot.statusError ? "Saved insights could not be loaded." : "Loading saved insights…"
+    : "No recent memories learned from activity. Open Manage memories to see everything already saved.";
+  const markup = memories.length ? memories.map((memory) => `<article class="co-worker-record">
+    ${recordContentMarkup(memory.content)}
+    <div class="co-worker-record-meta">${timeMarkup("Saved", memory.createdAt)}</div>
+  </article>`).join("") : `<p class="co-worker-knowledge-empty">${escapeHtml(empty)}</p>`;
+  replaceList(view, "memoryMarkup", "[data-learning-saved]", markup);
+}
+
+function candidateMarkup(candidate) {
+  const score = boundedScore(candidate.score);
+  const reinforcements = Array.isArray(candidate.reinforcements) ? candidate.reinforcements.length : 0;
+  const evidenceMarkup = "<span>" + Math.min(2, reinforcements) + " / 2 independent reinforcements</span>";
+  const dates = timeMarkup("Last reinforced", candidate.lastReinforcedAt) + timeMarkup("Expires", candidate.expiresAt);
+  const scoreMarkup = score === null ? "Not scored" : `<meter min="0" max="100" value="${score}" aria-label="Model assessment: ${score} out of 100">${score}</meter><span>${score} / 100</span>`;
+  return `<article class="co-worker-record" data-learning-candidate-id="${escapeAttribute(candidate.id)}">
+    ${recordContentMarkup(candidate.content)}
+    <div class="co-worker-record-footer"><span class="co-worker-record-score">${scoreMarkup}</span>
+      ${dates || candidate.reason ? `<details class="co-worker-record-details"><summary>Why this candidate</summary>
+        ${candidate.reason ? `<p class="co-worker-record-reason" dir="auto">${escapeHtml(candidate.reason)}</p>` : ""}
+        <div class="co-worker-record-meta">${evidenceMarkup}${dates}</div></details>` : ""}
+    </div>
+  </article>`;
+}
+
+function recordContentMarkup(value) {
+  const text = typeof value === "string" ? value : "";
+  if (text.length <= 240 && text.split("\n").length < 4)
+    return `<p class="co-worker-record-content" dir="auto">${escapeHtml(text)}</p>`;
+  return `<details class="co-worker-record-reading"><summary>
+    <span class="co-worker-record-content" dir="auto">${escapeHtml(text)}</span>
+    <span class="co-worker-record-read-more">Read more</span><span class="co-worker-record-read-less">Show less</span>
+  </summary></details>`;
+}
+
+function boundedScore(value) {
+  return typeof value === "number" && Number.isFinite(value) ? Math.min(100, Math.max(0, Math.round(value))) : null;
+}
+
+function timeMarkup(label, value) {
+  if (!Number.isFinite(Date.parse(value || ""))) return "";
+  return `<span>${label} <time datetime="${escapeAttribute(value)}">${escapeHtml(learningTimeLabel(value))}</time></span>`;
+}
+
+function setText(root, selector, value) {
+  const element = root.querySelector(selector);
+  if (element.textContent !== value) element.textContent = value;
+}
+
+function replaceList(view, key, selector, markup) {
+  if (view[key] === markup) return;
+  view[key] = markup;
+  view.host.querySelector(selector).innerHTML = markup;
+}

package/dist/src/web-ui/app/components/passive-learning/macos-collection-consent.js

@@ -0,0 +1,78 @@
+import { macCompanionPermissionPath } from "../system-host/macos-permissions.js";
+import { createMacPermissionDialog } from "../system-host/macos-permission-dialog.js";
+
+function requiresMacCollectionConsent(preferences, snapshot) {
+  if (preferences.enabled !== true) return false;
+  if (snapshot.status?.preferences?.enabled !== false) return false;
+  return Boolean(macCompanionPermissionPath(snapshot.hostConnection));
+}
+
+function collectionConsentContext(snapshot) {
+  const host = snapshot.hostConnection;
+  return JSON.stringify([
+    snapshot.environmentId,
+    host?.hostId,
+    host?.connected,
+    host?.connectionId,
+    host?.identity?.os,
+    host?.identity?.homeDir,
+    host?.companion?.installedVersion,
+  ]);
+}
+
+function canContinueCollectionStart(snapshot, context) {
+  if (snapshot.saving) return false;
+  if (snapshot.status?.preferences?.enabled !== false) return false;
+  if (!macCompanionPermissionPath(snapshot.hostConnection)) return false;
+  return collectionConsentContext(snapshot) === context;
+}
+
+/** Covers explicit collection starts from Home, Spark controls and Settings. */
+export function createMacCollectionConsent({
+  actions,
+  container,
+  createDialog = createMacPermissionDialog,
+}) {
+  let dialog;
+  let pending;
+
+  function cancel() {
+    pending = undefined;
+    dialog?.cancel();
+  }
+  async function confirmStart(preferences, request, path) {
+    try {
+      dialog ??= createDialog({ container });
+      const approved = await dialog.confirm(path);
+      if (pending !== request) return;
+      if (!approved) return;
+      if (!canContinueCollectionStart(actions.snapshot(), request.context))
+        return;
+      pending = undefined;
+      return actions.configure(preferences);
+    } finally {
+      if (pending === request) pending = undefined;
+    }
+  }
+  return {
+    configure(preferences) {
+      if (pending) return;
+      const snapshot = actions.snapshot();
+      if (!requiresMacCollectionConsent(preferences, snapshot))
+        return actions.configure(preferences);
+      if (snapshot.saving) return;
+      const request = { context: collectionConsentContext(snapshot) };
+      pending = request;
+      return confirmStart(
+        preferences,
+        request,
+        macCompanionPermissionPath(snapshot.hostConnection),
+      );
+    },
+    update(snapshot) {
+      if (!pending) return;
+      if (!canContinueCollectionStart(snapshot, pending.context)) cancel();
+    },
+    cancel,
+  };
+}

package/dist/src/web-ui/app/components/passive-learning/macos-collection-restart-notice.js

@@ -0,0 +1,52 @@
+const permissionReasons = new Set([
+  "macos_accessibility_permission_required",
+  "macos_accessibility_permission_timeout",
+  "macos_accessibility_permission_revoked",
+]);
+
+function hasEnabledMacCollection(snapshot) {
+  if (snapshot.hostConnection?.identity?.os !== "macos") return false;
+  return snapshot.status?.preferences?.enabled === true;
+}
+
+export function hasMacCollectionPermissionBlock(snapshot) {
+  if (!hasEnabledMacCollection(snapshot)) return false;
+  if (snapshot.status.collectionState !== "permission_required") return false;
+  return permissionReasons.has(snapshot.status.collectionReason);
+}
+
+function canRestartMacCollection(snapshot, actions) {
+  if (!hasMacCollectionPermissionBlock(snapshot)) return false;
+  if (snapshot.saving || snapshot.loadingStatus) return false;
+  if (snapshot.restartingCollection) return false;
+  return typeof actions.restartCollection === "function";
+}
+
+export function macCollectionRestartNoticeMarkup() {
+  return `<div class="co-worker-computer-update" data-learning-mac-restart hidden role="status">
+    <span class="co-worker-computer-update-icon" aria-hidden="true">↻</span>
+    <div class="co-worker-computer-update-copy"><p class="co-worker-computer-update-title">Spark needs Accessibility access</p>
+      <p>Already granted access? Restart collection to check again.</p></div>
+    <button type="button" data-learning-restart-collection>Restart collection</button>
+  </div>`;
+}
+
+export function renderMacCollectionRestartNotice(root, snapshot) {
+  const notice = root.querySelector("[data-learning-mac-restart]");
+  const blocked = hasMacCollectionPermissionBlock(snapshot);
+  const restartingMacCollection = hasEnabledMacCollection(snapshot) && snapshot.restartingCollection;
+  notice.hidden = !blocked && !restartingMacCollection;
+  notice.setAttribute("aria-busy", String(Boolean(snapshot.restartingCollection)));
+  const button = notice.querySelector("[data-learning-restart-collection]");
+  button.disabled = Boolean(snapshot.saving || snapshot.loadingStatus || snapshot.restartingCollection || !blocked);
+  button.textContent = snapshot.restartingCollection ? "Restarting collection…" : "Restart collection";
+}
+
+export function handleMacCollectionRestartClick(root, event, actions) {
+  const button = event.target.closest("[data-learning-restart-collection]");
+  if (!button || !root.contains(button)) return false;
+  if (button.disabled) return true;
+  if (!canRestartMacCollection(actions.snapshot(), actions)) return true;
+  void actions.restartCollection();
+  return true;
+}

package/dist/src/web-ui/app/components/passive-learning/memory.js

@@ -0,0 +1,235 @@
+import { renderAgent } from "./agent-view.js";
+import { renderComputerUpdateNotice } from "./computer-update-notice.js";
+import { renderMacCollectionRestartNotice, handleMacCollectionRestartClick } from "./macos-collection-restart-notice.js";
+import { learningCadenceLabel } from "./agent-state.js";
+import { renderLearningDiagnostics } from "./diagnostics-view.js";
+import { isObservationReviewActive } from "./processing-state.js";
+import { createAgentMotion } from "./agent-motion.js";
+import { createLearningSettings } from "./settings.js";
+import { handleActivityControlClick, renderActivityControls } from "./activity-controls.js";
+import { createLearningApplications } from "./applications-view.js";
+import { renderResourceUsage } from "./usage-view.js";
+import { renderLearningKnowledge, handleKnowledgeClick } from "./knowledge-view.js";
+import { renderLearningProposals, handleProposalClick } from "./proposal-view.js";
+import { escapeAttribute, escapeHtml } from "../../lib/text-format.js";
+import { learningBatchStatusLabel, renderLearningBatchDetail } from "./batch-detail.js";
+import { learningWorkspaceMarkup, navigateLearningTabs, selectLearningView } from "./workspace-view.js";
+import {
+  learningCoveragePresentation,
+  learningFailurePresentation,
+  learningProcessingLabel,
+  learningRetentionText,
+  hasUnprocessedLearningActivity,
+  learningTimeLabel,
+} from "./presentation.js";
+
+const defaultTimeZone = () => Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+
+export function createPassiveLearningMemory({
+  actions, showActivityMemories, openComputerAccess,
+  confirmDelete = (message) => window.confirm(message),
+}) {
+  let root = null;
+  let settings;
+  let applications;
+  let motion;
+  let displayedBatch = null;
+  let displayedBatchId = "";
+  let displayedDetailError = "";
+  let displayedDetailLoading = false;
+  let lastBatchMarkup = "";
+
+  function mount(nextRoot) {
+    if (root === nextRoot) return;
+    motion?.dispose();
+    root?.removeEventListener("click", handleClick);
+    root?.removeEventListener("submit", handleSubmit);
+    root?.removeEventListener("change", handleChange);
+    root?.removeEventListener("input", handleChange);
+    root?.removeEventListener("keydown", handleKeyDown);
+    root = nextRoot;
+    if (!root) return;
+    displayedBatch = null;
+    displayedBatchId = "";
+    lastBatchMarkup = "";
+    root.innerHTML = learningWorkspaceMarkup(defaultTimeZone());
+    settings = createLearningSettings({ root, actions, openSettings: () => selectLearningView(root, "settings") });
+    applications = createLearningApplications({ root, actions });
+    motion = createAgentMotion(root);
+    root.addEventListener("click", handleClick);
+    root.addEventListener("submit", handleSubmit);
+    root.addEventListener("change", handleChange);
+    root.addEventListener("input", handleChange);
+    root.addEventListener("keydown", handleKeyDown);
+    render(actions.snapshot());
+  }
+
+  function handleChange(event) {
+    if (applications.handleChange(event)) return;
+    settings.handleChange(event); renderControls(actions.snapshot());
+  }
+  function handleSubmit(event) { settings.handleSubmit(event); }
+
+  function handleKeyDown(event) {
+    navigateLearningTabs(root, event);
+  }
+
+  function handleClick(event) {
+    if (handleActivityControlClick(root, event, actions, () => selectLearningView(root, "settings"))) return;
+    if (handleMacCollectionRestartClick(root, event, actions)) return;
+    if (handleKnowledgeClick(root, event)) return;
+    if (handleProposalClick(root, event, actions)) return;
+    if (event.target.closest("[data-learning-open-settings]")) {
+      selectLearningView(root, "settings", true);
+      return;
+    }
+    const tab = event.target.closest("button[data-learning-tab]");
+    if (tab && root.contains(tab)) {
+      selectLearningView(root, tab.dataset.learningTab);
+      return;
+    }
+    const clearPending = event.target.closest("button[data-learning-clear-pending]");
+    if (clearPending && root.contains(clearPending)) {
+      deletePending();
+      return;
+    }
+    const setupButton = event.target.closest("button[data-learning-open-setup]") ??
+      event.target.closest("button[data-learning-open-update]") ??
+      event.target.closest("button[data-learning-computer-access]");
+    if (setupButton && root.contains(setupButton)) {
+      openComputerAccess();
+      return;
+    }
+    const button = event.target.closest("button[data-learning-refresh], button[data-learning-batch], button[data-learning-memories]");
+    if (!button || !root.contains(button)) return;
+    if (button.hasAttribute("data-learning-refresh")) void actions.refresh();
+    if (button.hasAttribute("data-learning-batch")) {
+      const previousId = actions.snapshot().selectedBatchId;
+      const nextId = button.dataset.learningBatch;
+      void actions.selectBatch(nextId);
+      if (!nextId) {
+        const previousButton = [...root.querySelectorAll("[data-learning-batches] button")]
+          .find((item) => item.dataset.learningBatch === previousId);
+        previousButton?.focus({ preventScroll: true });
+      }
+    }
+    if (button.hasAttribute("data-learning-memories"))
+      showActivityMemories();
+  }
+
+  function deletePending() {
+    const snapshot = actions.snapshot();
+    if (!snapshot.status || snapshot.saving) return;
+    if (!hasUnprocessedLearningActivity(snapshot.status)) return;
+    if (!confirmDelete("Delete all pending activity, including any review in progress? Saved insights are kept. This cannot be undone.")) return;
+    void actions.clearPending();
+  }
+
+
+  function renderControls(snapshot) {
+    const status = snapshot.status;
+    const disabled = snapshot.saving || !status;
+    renderActivityControls(root, snapshot);
+    root.querySelector("[data-learning-clear-pending]").disabled = disabled || !hasUnprocessedLearningActivity(status);
+  }
+
+  function renderStatus(snapshot) {
+    const status = snapshot.status;
+    const companion = snapshot.hostConnection?.companion;
+    renderComputerUpdateNotice(root, snapshot);
+    renderMacCollectionRestartNotice(root, snapshot);
+    root.querySelector("[data-learning-companion-version]").textContent = companion
+      ? `Installed version: ${companion.installedVersion ?? "unversioned"} · Available: ${companion.availableVersion}` : "Connect your computer to check its companion version.";
+    const attention = learningFailurePresentation(status);
+    const coverage = learningCoveragePresentation(status);
+    root.querySelector("[data-learning-attention]").hidden = !attention;
+    root.querySelector("[data-learning-attention-text]").textContent = attention?.message || "";
+    root.querySelector("[data-learning-open-setup]").hidden = !attention?.connectComputer;
+    root.querySelector("[data-learning-processing-status]").textContent = learningProcessingLabel(status);
+    root.querySelector("[data-learning-retention]").textContent = learningRetentionText(status);
+    const modelId = status?.preferences?.modelProfileId;
+    const model = snapshot.models.find((profile) => profile.id === modelId);
+    root.querySelector("[data-learning-schedule-summary]").textContent = modelId
+      ? `${model?.label || modelId} · ${learningCadenceLabel(status.preferences)}`
+      : "Choose a model in Settings to get started.";
+    root.querySelector("[data-learning-device]").textContent = status?.deviceId || "Not connected now";
+    root.querySelector("[data-learning-coverage]").textContent = coverage.label;
+    root.querySelector("[data-learning-coverage-detail]").textContent = coverage.detail;
+    const reasons = [status?.collectionReason, status?.processingReason, status?.reason, status?.proactive?.reason, status?.reassessment?.reason, status?.maintenanceReason].filter(Boolean);
+    root.querySelector("[data-learning-diagnostics]").hidden = !reasons.length;
+    renderLearningDiagnostics(root.querySelector("[data-learning-reason]"), reasons);
+    root.querySelector("[data-learning-observation]").textContent =
+      learningTimeLabel(status?.lastObservationAt);
+    root.querySelector("[data-learning-pending]").textContent = status
+      ? `${status.pendingObservations || 0} waiting${status.droppedObservations ? ` · ${status.droppedObservations} dropped` : ""}`
+      : "—";
+    const processingActive = !snapshot.statusError && isObservationReviewActive(status);
+    root.querySelector("[data-learning-pending-fact]").setAttribute("data-processing-active", String(processingActive));
+    root.querySelector("[data-learning-processing-badge]").hidden = !processingActive;
+    root.querySelector("[data-learning-analysis]").textContent = status
+      ? `${status.activeBatches ?? 0} active · ${status.effectiveConcurrency ?? 1} parallel${status.nextAnalysisAt ? ` · next ${learningTimeLabel(status.nextAnalysisAt)}` : ""}`
+      : "—";
+    const feedback = snapshot.statusError || snapshot.modelsError || snapshot.batchError;
+    root.querySelector("[data-learning-feedback]").textContent = feedback ||
+      (snapshot.loadingStatus ? "Loading learning status…" : "");
+  }
+
+  function renderBatches(snapshot) {
+    const list = root.querySelector("[data-learning-batches]");
+    if (snapshot.loadingBatches && !snapshot.batches.length) {
+      lastBatchMarkup = "";
+      list.textContent = "Loading reviews…";
+      return;
+    }
+    if (!snapshot.batches.length) {
+      lastBatchMarkup = "";
+      list.textContent = "No activity has been reviewed yet.";
+      return;
+    }
+    const markup = snapshot.batches.map((batch) =>
+      `<button type="button" class="passive-learning-batch" data-learning-batch="${escapeAttribute(batch.id)}" aria-pressed="${batch.id === snapshot.selectedBatchId}">
+        <span class="passive-learning-batch-heading"><time datetime="${escapeAttribute(batch.createdAt)}">${escapeHtml(learningTimeLabel(batch.createdAt))}</time><span>${escapeHtml(learningBatchStatusLabel(batch.status))}</span></span>
+        <small>${Number(batch.observationCount) || 0} observations · ${batch.recordIds?.length || 0} saved · ${batch.candidateIds?.length || 0} candidates</small>
+      </button>`).join("");
+    if (lastBatchMarkup !== markup) {
+      lastBatchMarkup = markup;
+      list.innerHTML = markup;
+    }
+  }
+
+  function renderBatchDetail(snapshot) {
+    const container = root.querySelector("[data-learning-detail]");
+    const batch = snapshot.selectedBatch;
+    if (snapshot.selectedBatchId === displayedBatchId &&
+        batch === displayedBatch &&
+        snapshot.detailError === displayedDetailError &&
+        snapshot.loadingDetail === displayedDetailLoading) return;
+    displayedBatchId = snapshot.selectedBatchId;
+    displayedBatch = batch;
+    displayedDetailError = snapshot.detailError;
+    displayedDetailLoading = snapshot.loadingDetail;
+    renderLearningBatchDetail(container, snapshot);
+  }
+
+  function render(snapshot) {
+    if (!root) return;
+    settings.render(snapshot);
+    applications.render(snapshot);
+    renderControls(snapshot);
+    renderAgent(root, snapshot);
+    motion.update(snapshot);
+    renderStatus(snapshot);
+    renderBatches(snapshot);
+    renderBatchDetail(snapshot);
+    renderLearningKnowledge(root, snapshot);
+    renderLearningProposals(root, snapshot);
+    renderResourceUsage(root, snapshot);
+  }
+
+  function focus() {
+    root?.querySelector("[data-learning-heading]")?.focus({ preventScroll: true });
+    root?.scrollIntoView({ block: "start", behavior: "smooth" });
+  }
+
+  return Object.freeze({ mount, render, focus });
+}