@celestia-island/hikari 0.55.105 → 0.55.107

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celestia-island/hikari",
-  "version": "0.55.105",
+  "version": "0.55.107",
   "private": false,
   "type": "module",
   "description": "Hikari Vue 3 component library — production-grade UI components based on shittim-chest design system",

package/src/components/HkConnectionStatus.tsx

@@ -124,7 +124,12 @@ export const HkConnectionStatus = defineComponent({
               attemptNumber={probe.value.attemptNumber}
               countdown={probe.value.countdown}
               compact={props.compact}
-            />
+            >
+              {/* Host-appended popover actions (e.g. a manual page
+                  refresh) ride the same actions row as the built-in
+                  retry button. */}
+              {{ actions: () => slots.actions?.() }}
+            </HkStatusBar>
             {bs && (
               <span class="s-status-bar-tag" style={{ cursor: "default" }}>
                 <span

package/src/components/HkErrorLanding.inline.contract.test.ts

@@ -1,13 +1,14 @@
 /**
- * Source contract: the inline landing sits FLUSH under its context. The
- * `.is-inline` variant must drop the viewport takeover's block-axis
- * padding entirely (the host pane already pads and a sibling header sits
- * immediately above — the old 1.25rem top padding floated the card a
- * full padding-frame below its context) and slim the card's page-grade
- * top padding (2.25rem desktop / 1.75rem mobile) to one space step. The
- * horizontal inset stays so a narrow pane never seats the card
- * edge-to-edge. A class-name test cannot see this; the compiled contract
- * lives here.
+ * Source contract: the inline landing CENTERS inside its host region. The
+ * `.is-inline` variant must fill the host container's height (so the base
+ * centering seats the card mid-container — the inline twin of the page
+ * variant centering in the viewport), carry no block-axis padding (the
+ * #695 lesson: a hardcoded top inset read as "floating too low" under a
+ * sibling header), and center the card via overflow-safe auto margins
+ * (collapse to top-anchored when the card is taller than the container,
+ * instead of a both-edge clip nothing can scroll to). The horizontal
+ * inset stays so a narrow pane never seats the card edge-to-edge. A
+ * class-name test cannot see this; the compiled contract lives here.
  */
 import { describe, expect, it } from "vitest";
 import { readFileSync } from "node:fs";
@@ -16,7 +17,32 @@ import { fileURLToPath } from "node:url";
 
 const here = dirname(fileURLToPath(import.meta.url));
 
-/** Extract one rule's body with nesting-aware brace matching. */
+/** Strip SCSS comments — line and block form — so a contract literal can
+ *  only ever be satisfied by a REAL declaration, never by prose: a
+ *  commented-out `margin: auto` (line-comment mutation found in R1,
+ *  block-comment in R2) would otherwise false-green `toContain`. A `//`
+ *  preceded by `:` is a URL scheme (`https://`) and survives. Block
+ *  comments go first so a `//` hidden inside them can't leak through. */
+function stripComments(css: string): string {
+  return stripLineComments(css.replace(/\/\*[\s\S]*?\*\//g, ""));
+}
+
+/** Strip SCSS `//` line comments; `://` URL schemes survive. */
+function stripLineComments(css: string): string {
+  return css
+    .split("\n")
+    .map((line) => {
+      let i = line.indexOf("//");
+      while (i !== -1 && line[i - 1] === ":") {
+        i = line.indexOf("//", i + 1);
+      }
+      return i === -1 ? line : line.slice(0, i);
+    })
+    .join("\n");
+}
+
+/** Extract one rule's body with nesting-aware brace matching, prose
+ *  stripped. */
 function ruleBody(css: string, selector: string): string {
   const start = css.indexOf(`${selector} {`);
   expect(start, `rule ${selector} present`).toBeGreaterThanOrEqual(0);
@@ -26,23 +52,57 @@ function ruleBody(css: string, selector: string): string {
     if (css[i] === "{") depth++;
     else if (css[i] === "}") {
       depth--;
-      if (depth === 0) return css.slice(open + 1, i);
+      if (depth === 0) return stripComments(css.slice(open + 1, i));
     }
   }
   throw new Error(`unbalanced braces in ${selector}`);
 }
 
+describe("contract-test comment stripping", () => {
+  it("strips comments (positive control — the guard must be able to bite)", () => {
+    // Without this control a broken stripper would silently turn every
+    // assertion above into prose-matching; 0-strip must be LOUD.
+    const dirty = "// min-height: 100%\n  min-height: 100%;";
+    expect(stripComments(dirty)).not.toContain("//");
+    expect(stripComments(dirty).trim()).toBe("min-height: 100%;");
+    // Block comments are prose too (the R2 mutation shape: a commented-out
+    // declaration must never satisfy the contract).
+    const blocked = "margin: initial; /* margin: auto */";
+    expect(stripComments(blocked)).toContain("margin: initial;");
+    expect(stripComments(blocked)).not.toContain("margin: auto");
+    // URL schemes survive intact.
+    expect(stripComments('icon: url("https://cdn.example/x.svg");')).toContain("://");
+  });
+});
+
 describe("HkErrorLanding inline contract", () => {
   const css = readFileSync(join(here, "HkErrorLanding.scss"), "utf-8");
   const inline = ruleBody(css, ".hk-error-landing.is-inline");
 
+  it("fills the host region's height so the shared centering can seat the card", () => {
+    // `min-height: 0` collapsed the root to its content height, which
+    // silently disabled the base align/justify centering and glued the
+    // card to the container's top edge.
+    expect(inline).toContain("min-height: 100%");
+    expect(inline).not.toContain("min-height: 0");
+  });
+
   it("drops the block-axis padding entirely and keeps only the horizontal inset", () => {
-    expect(inline).toContain("min-height: 0");
     expect(inline).toContain("padding: 0 var(--space-12, 0.75rem)");
     // The takeover padding must not survive in any form.
     expect(inline).not.toContain("1.25rem");
   });
 
+  it("centers the card through overflow-safe auto margins", () => {
+    const card = ruleBody(inline, ".hk-error-landing__card");
+    // Auto margins absorb positive free space (centering) and collapse to
+    // 0 on overflow (no both-edge clip).
+    expect(card).toContain("margin: auto");
+    // The overflow anchor: with the margins collapsed the card must pin
+    // to the container's TOP edge — reachable — never float mid-clip.
+    expect(inline).toContain("align-items: flex-start");
+  });
+
   it("slims the card's top padding below the page-grade value", () => {
     const card = ruleBody(inline, ".hk-error-landing__card");
     // The shorthand's block-start value IS the slim step, not the
@@ -63,3 +123,20 @@ describe("HkErrorLanding multiline headline contract", () => {
     expect(title).toContain("overflow-wrap: anywhere");
   });
 });
+
+describe("HkErrorLanding page-variant seating contract", () => {
+  const css = readFileSync(join(here, "HkErrorLanding.scss"), "utf-8");
+  const base = ruleBody(css, ".hk-error-landing");
+
+  it("fills the viewport and centers the card in it", () => {
+    // The page variant's whole seating model: a full-viewport backdrop
+    // with the card centered in it (standalone error pages, the chest
+    // overlay, the reporting takeover all ride this rule). R2 flipped
+    // align-items to flex-end and every landing test stayed green — this
+    // pin closes that hole.
+    expect(base).toContain("min-height: 100vh");
+    expect(base).toContain("min-height: 100dvh");
+    expect(base).toContain("align-items: center");
+    expect(base).toContain("justify-content: center");
+  });
+});

package/src/components/HkErrorLanding.scss

@@ -276,21 +276,42 @@
 // in-place instead of covering the whole screen, or when a host view
 // renders it as its failed content region right under a sibling header.
 .hk-error-landing.is-inline {
-  min-height: 0;
-  // In-pane, the host region already pads and a sibling header usually
-  // sits immediately above: the takeover's block-axis padding floated
-  // the card a full padding-frame below its context. The vertical
-  // padding is dropped entirely (the card's own slimmer top padding
-  // below supplies the breathing room); the horizontal inset stays so a
-  // narrow pane never seats the card edge-to-edge.
+  // Fill the HOST REGION's height so the base centering (the align/justify
+  // center on .hk-error-landing — this element matches that selector too,
+  // which is how the centering reaches the inline variant) seats the card
+  // in the middle
+  // of whatever container it landed in — the inline twin of the page
+  // variant centering in the viewport. The old zero min-height collapsed
+  // the root to its content height, which silently disabled that
+  // centering and glued the card to the container's top edge; the #695
+  // padding removal traded "a padding-frame too low" for "flush against
+  // the header". Both were symptoms of spacing-by-inset; centering in the
+  // actual container fixes both hosts at once. A host whose height is
+  // auto (a growing content column, not a framed pane) resolves the
+  // percentage to nothing and keeps a content-sized, top-seated landing
+  // — centering applies exactly as far as the container can express it.
+  min-height: 100%;
+  // The horizontal inset stays so a narrow pane never seats the card
+  // edge-to-edge. No block-axis padding: the gap above/below the card is
+  // the centering's job now — a hardcoded top inset is exactly what read
+  // as "floating too low" under a sibling header in #695.
   padding: 0 var(--space-12, 0.75rem);
+  // Explicit overflow anchor: with the card's auto margins below
+  // collapsed there is no free space left to center in, and the alignment
+  // that then applies must be the START edge — reachable top, clip only
+  // at the unreachable bottom. Spelled out (and pinned by the contract
+  // test) rather than left emergent from the inherited center; with free
+  // space the margins absorb it before alignment ever applies, so this
+  // line only ever shows on overflow.
+  align-items: flex-start;
   background: transparent;
 
-  // The card's page-grade top padding (2.25rem desktop / 1.75rem mobile)
-  // reads as a detached float inside a pane — slim it to one space step.
-  // Specificity (0,3,0) outranks the ≤480px media rule (0,1,0), so this
-  // holds on phones too.
+  // Safe centering: auto margins center the card on both axes while free
+  // space exists and collapse to 0 when it doesn't (the overflow case
+  // anchored by align-items above). Specificity (0,3,0) also keeps the
+  // slim padding below outranking the ≤480px media rule (0,1,0).
   .hk-error-landing__card {
+    margin: auto;
     padding: var(--space-16, 1rem) var(--space-28, 1.75rem) var(--space-24, 1.5rem);
   }
 }

package/src/components/HkErrorLanding.tsx

@@ -25,8 +25,10 @@ export type HErrorTone = "error" | "warning" | "info";
  * Layout variant of the landing.
  * - `page` (default): owns a full-viewport backdrop — for overlays and
  *   standalone error pages.
- * - `inline`: drops the backdrop and viewport height so the same card can
- *   live inside a pane captured by HkErrorBoundary.
+ * - `inline`: drops the backdrop and fills its host region's height
+ *   instead of the viewport, so the same card centers inside whatever
+ *   pane captured it (HkErrorBoundary) or whatever content region a host
+ *   view hands it.
  */
 export type HErrorLandingVariant = "page" | "inline";
 

package/src/components/HkStatusBar.test.tsx

@@ -322,4 +322,145 @@ describe("HkStatusBar", () => {
       vi.useRealTimers();
     }
   });
+
+  it("shows a working reconnect button in the popover while disconnected (hint text retired)", async () => {
+    const onRetry = vi.fn();
+    const container = mountBar({
+      version: "1.2.3",
+      connectionStatus: "disconnected",
+      connectionInfo: INFO,
+      onRetry,
+    });
+    await nextTick();
+    container
+      .querySelector<HTMLElement>(".s-status-bar-tag")!
+      .dispatchEvent(new MouseEvent("mouseenter"));
+    await nextTick();
+    const panel = document.body.querySelector<HTMLElement>(".hk-popover-panel")!;
+    // The popover body teleports to <body>: the old italic "click to
+    // retry" hint pointed at an element whose clicks never reached the
+    // tag handler. The actions row carries a REAL button instead, and
+    // the misleading hint is gone whenever a retry is wired.
+    const row = panel.querySelector<HTMLElement>("[data-status-actions]")!;
+    expect(row, "actions row renders").toBeTruthy();
+    const button = row.querySelector<HTMLButtonElement>("button")!;
+    expect(button.textContent).toContain("Reconnect now");
+    expect(panel.textContent).not.toContain("Click to retry");
+    button.click();
+    expect(onRetry, "popover button click retries").toHaveBeenCalledTimes(1);
+  });
+
+  it("keeps the fallback hint when no onRetry is wired", async () => {
+    const container = mountBar({
+      version: "1.2.3",
+      connectionStatus: "disconnected",
+      connectionInfo: INFO,
+    });
+    await nextTick();
+    container
+      .querySelector<HTMLElement>(".s-status-bar-tag")!
+      .dispatchEvent(new MouseEvent("mouseenter"));
+    await nextTick();
+    const panel = document.body.querySelector<HTMLElement>(".hk-popover-panel")!;
+    expect(panel.querySelector("[data-status-actions]")).toBeNull();
+    expect(panel.textContent).toContain("Click to retry");
+  });
+
+  it("renders host actions through the actions slot, connected or not", async () => {
+    for (const connectionStatus of ["connected", "disconnected"] as const) {
+      document.body.innerHTML = "";
+      const onRefresh = vi.fn();
+      const container = document.createElement("div");
+      document.body.appendChild(container);
+      const app = createApp({
+        render: () =>
+          h(HkStatusBar, {
+            version: "1.2.3",
+            connectionStatus,
+            connectionInfo: INFO,
+            onRetry: () => {},
+          }, {
+            actions: () => h("button", { class: "host-refresh", onClick: onRefresh }, "Refresh page"),
+          }),
+      });
+      app.mount(container);
+      mounts.push({ app, container });
+      await nextTick();
+      container
+        .querySelector<HTMLElement>(".s-status-bar-tag")!
+        .dispatchEvent(new MouseEvent("mouseenter"));
+      await nextTick();
+      const panel = document.body.querySelector<HTMLElement>(".hk-popover-panel")!;
+      const host = panel.querySelector<HTMLButtonElement>(".host-refresh")!;
+      expect(host, `host action renders (${connectionStatus})`).toBeTruthy();
+      expect(panel.querySelector("[data-status-actions]")).toBeTruthy();
+      host.click();
+      expect(onRefresh).toHaveBeenCalledTimes(1);
+    }
+  });
+
+  it("no actions row when connected without host actions", async () => {
+    const container = mountBar({
+      version: "1.2.3",
+      connectionStatus: "connected",
+      connectionInfo: INFO,
+      onRetry: () => {},
+    });
+    await nextTick();
+    container
+      .querySelector<HTMLElement>(".s-status-bar-tag")!
+      .dispatchEvent(new MouseEvent("mouseenter"));
+    await nextTick();
+    const panel = document.body.querySelector<HTMLElement>(".hk-popover-panel");
+    expect(panel!.querySelector("[data-status-actions]")).toBeNull();
+  });
+
+  it("keeps the actions row available while connection info is still fetching", async () => {
+    const onRetry = vi.fn();
+    const container = mountBar({
+      version: "1.2.3",
+      connectionStatus: "disconnected",
+      connectionInfo: null,
+      onRetry,
+    });
+    await nextTick();
+    container
+      .querySelector<HTMLElement>(".s-status-bar-tag")!
+      .dispatchEvent(new MouseEvent("mouseenter"));
+    await nextTick();
+    const panel = document.body.querySelector<HTMLElement>(".hk-popover-panel")!;
+    // The row must live OUTSIDE the info/fetching ternary: an outage that
+    // drops connectionInfo to null is exactly when the retry button is
+    // most needed.
+    const button = panel.querySelector<HTMLButtonElement>("[data-status-actions] button");
+    expect(button, "retry button renders without info").toBeTruthy();
+    button!.click();
+    expect(onRetry).toHaveBeenCalledTimes(1);
+  });
+
+  it("no actions row when the slot renders nothing (wrapper forwards an empty slot)", async () => {
+    const container = document.createElement("div");
+    document.body.appendChild(container);
+    const app = createApp({
+      render: () =>
+        h(HkStatusBar, {
+          version: "1.2.3",
+          connectionStatus: "connected",
+          connectionInfo: INFO,
+        }, {
+          // HkConnectionStatus forwards `actions` unconditionally; an
+          // empty render must not paint a hairline-only row.
+          actions: () => [],
+        }),
+    });
+    app.mount(container);
+    mounts.push({ app, container });
+    await nextTick();
+    container
+      .querySelector<HTMLElement>(".s-status-bar-tag")!
+      .dispatchEvent(new MouseEvent("mouseenter"));
+    await nextTick();
+    const panel = document.body.querySelector<HTMLElement>(".hk-popover-panel");
+    expect(panel!.querySelector("[data-status-actions]")).toBeNull();
+  });
 });

package/src/components/HkStatusBar.tsx

@@ -5,6 +5,7 @@ import { useI18n } from "../i18n/context";
 import { HIKARI_FONT_MONO } from "../theme/fontContext";
 
 import HPopover from "./HkPopover";
+import HkButton from "./HkButton";
 import type { HkConnectionInfo } from "./HkConnectionInfo";
 import { HkCountdownDigit } from "./HkCountdownDigit";
 
@@ -112,7 +113,7 @@ export const HkStatusBar = defineComponent({
       default: undefined,
     },
   },
-  setup(props) {
+  setup(props, { slots }) {
     const popupOpen = ref(false);
     const anchorRef = ref<HTMLElement | null>(null);
     let closeTimer: ReturnType<typeof setTimeout> | null = null;
@@ -197,6 +198,16 @@ export const HkStatusBar = defineComponent({
       }
     }
 
+    // Popover retry button: the echo guard applies here too — a late
+    // synthetic click following the touch activation that opened the
+    // popover must not double-fire the retry through the button.
+    function onRetryButtonClick() {
+      if (Date.now() < touchEchoGuardUntil) return;
+      if (props.connectionStatus !== "connected") {
+        props.onRetry?.();
+      }
+    }
+
     // ── Touch activation ────────────────────────────────────────────
     // Mobile tap-to-retry used to ride the SYNTHESIZED mouse chain
     // (touchend → mouseenter → click → mouseleave), which browsers may
@@ -268,6 +279,22 @@ export const HkStatusBar = defineComponent({
         : t("hikari::statusBar.disconnected", "Disconnected");
 
       const connecting = mode === "reconnecting" || mode === "connecting";
+      // Actions row: the popover body teleports to <body>, so a click on
+      // the "click to reconnect" hint text inside it never reached the
+      // tag's own click handler — the popover now carries REAL buttons.
+      // The built-in one retriggers the reconnect for any non-green
+      // light; hosts append their own (e.g. a full manual refresh)
+      // through the `actions` slot.
+      const showRetryButton = mode !== "connected" && typeof props.onRetry === "function";
+      // Gate the row on RENDERED content, not on the slot function's
+      // existence: HkConnectionStatus forwards `actions` unconditionally,
+      // so a function-existence gate would paint an empty hairline row in
+      // the connected state for every host that passed no #actions.
+      const actionVnodes = slots.actions?.();
+      const hasHostActions = Array.isArray(actionVnodes)
+        ? actionVnodes.length > 0
+        : Boolean(actionVnodes);
+      const hasActionsRow = showRetryButton || hasHostActions;
 
       const pv = fmtVer(props.version, props.panelBuildHash);
       const ev = props.engineVersion;
@@ -370,7 +397,7 @@ export const HkStatusBar = defineComponent({
                       )}
                     </div>
                   )}
-                  {mode === "disconnected" && (
+                  {mode === "disconnected" && !showRetryButton && (
                     <div style={{ fontStyle: "italic", fontSize: "0.6875rem", marginBottom: "4px", opacity: 0.7 }}>
                       {t("hikari::statusBar.clickReconnect", "Click to retry")}
                     </div>
@@ -418,6 +445,26 @@ export const HkStatusBar = defineComponent({
               ) : (
                 <div style={{ opacity: 0.5 }}>{t("hikari::statusBar.fetching", "Fetching connection info...")}</div>
               )}
+              {hasActionsRow && (
+                <div
+                  data-status-actions
+                  style={{
+                    display: "flex",
+                    alignItems: "center",
+                    gap: "8px",
+                    marginTop: "8px",
+                    paddingTop: "8px",
+                    borderTop: "1px solid var(--border-faint, rgb(var(--color-border) / 10%))",
+                  }}
+                >
+                  {showRetryButton && (
+                    <HkButton size="sm" variant="secondary" onClick={onRetryButtonClick}>
+                      {t("hikari::statusBar.retryNow", "Reconnect now")}
+                    </HkButton>
+                  )}
+                  {hasHostActions ? actionVnodes : null}
+                </div>
+              )}
             </div>
           </HPopover>
         </>

package/src/i18n/locales/ar/components.json

@@ -150,6 +150,7 @@
     "hikari::statusBar.backend.unknown": "غير معروف",
     "hikari::statusBar.backend.warn": "متدهور",
     "hikari::statusBar.clickReconnect": "انقر لإعادة المحاولة",
+    "hikari::statusBar.retryNow": "أعد الاتصال الآن",
     "hikari::statusBar.connected": "متصل",
     "hikari::statusBar.connecting": "جارٍ الاتصال...",
     "hikari::statusBar.disconnected": "غير متصل",

package/src/i18n/locales/de/components.json

@@ -150,6 +150,7 @@
     "hikari::statusBar.backend.unknown": "Unbekannt",
     "hikari::statusBar.backend.warn": "Beeinträchtigt",
     "hikari::statusBar.clickReconnect": "Zum Wiederholen klicken",
+    "hikari::statusBar.retryNow": "Jetzt neu verbinden",
     "hikari::statusBar.connected": "Verbunden",
     "hikari::statusBar.connecting": "Verbinde...",
     "hikari::statusBar.disconnected": "Getrennt",

package/src/i18n/locales/en/components.json

@@ -150,6 +150,7 @@
     "hikari::statusBar.backend.unknown": "Unknown",
     "hikari::statusBar.backend.warn": "Degraded",
     "hikari::statusBar.clickReconnect": "Click to retry",
+    "hikari::statusBar.retryNow": "Reconnect now",
     "hikari::statusBar.connected": "Connected",
     "hikari::statusBar.connecting": "Connecting...",
     "hikari::statusBar.disconnected": "Disconnected",

package/src/i18n/locales/es/components.json

@@ -150,6 +150,7 @@
     "hikari::statusBar.backend.unknown": "Desconocido",
     "hikari::statusBar.backend.warn": "Degradado",
     "hikari::statusBar.clickReconnect": "Haga clic para reintentar",
+    "hikari::statusBar.retryNow": "Reconectar ahora",
     "hikari::statusBar.connected": "Conectado",
     "hikari::statusBar.connecting": "Conectando...",
     "hikari::statusBar.disconnected": "Desconectado",

package/src/i18n/locales/fr/components.json

@@ -150,6 +150,7 @@
     "hikari::statusBar.backend.unknown": "Inconnu",
     "hikari::statusBar.backend.warn": "Dégradé",
     "hikari::statusBar.clickReconnect": "Cliquez pour réessayer",
+    "hikari::statusBar.retryNow": "Reconnecter maintenant",
     "hikari::statusBar.connected": "Connecté",
     "hikari::statusBar.connecting": "Connexion...",
     "hikari::statusBar.disconnected": "Déconnecté",

package/src/i18n/locales/ja/components.json

@@ -150,6 +150,7 @@
     "hikari::statusBar.backend.unknown": "不明",
     "hikari::statusBar.backend.warn": "低下",
     "hikari::statusBar.clickReconnect": "クリックして再接続",
+    "hikari::statusBar.retryNow": "今すぐ再接続",
     "hikari::statusBar.connected": "接続済み",
     "hikari::statusBar.connecting": "接続中...",
     "hikari::statusBar.disconnected": "切断",

package/src/i18n/locales/ko/components.json

@@ -150,6 +150,7 @@
     "hikari::statusBar.backend.unknown": "알 수 없음",
     "hikari::statusBar.backend.warn": "저하",
     "hikari::statusBar.clickReconnect": "클릭하여 재연결",
+    "hikari::statusBar.retryNow": "지금 재연결",
     "hikari::statusBar.connected": "연결됨",
     "hikari::statusBar.connecting": "연결 중...",
     "hikari::statusBar.disconnected": "연결 끊김",

package/src/i18n/locales/pt/components.json

@@ -150,6 +150,7 @@
     "hikari::statusBar.backend.unknown": "Desconhecido",
     "hikari::statusBar.backend.warn": "Degradado",
     "hikari::statusBar.clickReconnect": "Clique para tentar novamente",
+    "hikari::statusBar.retryNow": "Reconectar agora",
     "hikari::statusBar.connected": "Conectado",
     "hikari::statusBar.connecting": "Conectando...",
     "hikari::statusBar.disconnected": "Desconectado",

package/src/i18n/locales/ru/components.json

@@ -150,6 +150,7 @@
     "hikari::statusBar.backend.unknown": "Неизвестно",
     "hikari::statusBar.backend.warn": "Деградация",
     "hikari::statusBar.clickReconnect": "Нажмите, чтобы повторить",
+    "hikari::statusBar.retryNow": "Переподключиться сейчас",
     "hikari::statusBar.connected": "Подключено",
     "hikari::statusBar.connecting": "Подключение...",
     "hikari::statusBar.disconnected": "Отключено",

package/src/i18n/locales/zh-Hans/components.json

@@ -150,6 +150,7 @@
     "hikari::statusBar.backend.unknown": "未知",
     "hikari::statusBar.backend.warn": "降级",
     "hikari::statusBar.clickReconnect": "点击以尝试重连",
+    "hikari::statusBar.retryNow": "立即重连",
     "hikari::statusBar.connected": "已连接",
     "hikari::statusBar.connecting": "连接中...",
     "hikari::statusBar.disconnected": "断开",

package/src/i18n/locales/zh-Hant/components.json

@@ -150,6 +150,7 @@
     "hikari::statusBar.backend.unknown": "未知",
     "hikari::statusBar.backend.warn": "降級",
     "hikari::statusBar.clickReconnect": "點擊以嘗試重連",
+    "hikari::statusBar.retryNow": "立即重連",
     "hikari::statusBar.connected": "已連線",
     "hikari::statusBar.connecting": "連線中...",
     "hikari::statusBar.disconnected": "斷開",