@celestia-island/hikari 0.55.149 → 0.55.151

package/package.json

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

package/src/animation/registerAnimations.ts

@@ -110,7 +110,6 @@ registerCssAnimation("hk-flip-out");
 registerCssAnimation("hk-flip-in");
 // components/HkVoiceInputPopup.scss — voice waveform bounce (loops
 // forever while listening; upstreamed from chest's plana-legacy).
-registerCssAnimation("s-voice-wave-bounce", { infinite: true });
 // components/HkPlaceholderMarquee.scss — overflowing placeholder sweep
 // (loops forever; pure CSS, loop geometry on inline custom properties).
 registerCssAnimation("hk-placeholder-marquee-scroll", { infinite: true });

package/src/components/HkConnectionStatus.shell.test.tsx

@@ -0,0 +1,34 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { createApp, h } from "vue";
+
+import { HkConnectionStatus } from "./HkConnectionStatus";
+
+/** The shell contract: WITHOUT injections the component never touches
+ * the network — the fetch-poll was demoted with the chat kit (the M1
+ * mutation guard: a fetch in the fallback path must go red here). */
+const mounts: Array<{ app: ReturnType<typeof createApp>; container: HTMLElement }> = [];
+afterEach(() => {
+  for (const { app, container } of mounts.splice(0)) {
+    app.unmount();
+    container.remove();
+  }
+});
+
+describe("HkConnectionStatus (shell)", () => {
+  it("renders an inert unknown state with zero network calls", () => {
+    const fetchSpy = vi.fn();
+    const holder = globalThis.fetch;
+    globalThis.fetch = fetchSpy as unknown as typeof fetch;
+    try {
+      const container = document.createElement("div");
+      document.body.appendChild(container);
+      const app = createApp({ render: () => h(HkConnectionStatus, { standalone: true }) });
+      app.mount(container);
+      mounts.push({ app, container });
+      expect(fetchSpy).not.toHaveBeenCalled();
+      expect(container.textContent ?? "").not.toBeNull();
+    } finally {
+      globalThis.fetch = holder;
+    }
+  });
+});

package/src/components/HkConnectionStatus.tsx

@@ -1,8 +1,7 @@
-import { computed, defineComponent, inject, type InjectionKey, type PropType, type Ref } from "vue";
+import { computed, defineComponent, inject, ref, type InjectionKey, type PropType, type Ref } from "vue";
 
 import { useI18n } from "../i18n/context";
-import { useConnectionProbe, type ProbeResult } from "../composables/useConnectionProbe";
-import { useEngineHealth } from "../composables/useEngineHealth";
+import type { EngineHealth, EngineNetworkInfo, ProbeResult } from "../composables/engineHealthTypes";
 
 import { HkStatusBar } from "./HkStatusBar";
 import {
@@ -28,6 +27,25 @@ export interface HkConnectionProbeSource {
 }
 
 /** Injection key for the connection-probe overload (see above). */
+/** Engine-health source a host provides (the demoted fetch's
+ * replacement): a ref of the /api/health envelope, or null. */
+export const HK_ENGINE_HEALTH: InjectionKey<Ref<EngineHealth | null>> = Symbol(
+  "HK_ENGINE_HEALTH",
+);
+
+/** The shell's inert probe — no network, no timers: "unknown". */
+const INERT_PROBE: ProbeResult = {
+  connected: false,
+  state: "disconnected",
+  transportTier: "unknown",
+  tier: "unknown",
+  latencyMs: null,
+  attemptNumber: 0,
+  retryCount: 0,
+  retryTotal: 0,
+  countdown: 0,
+};
+
 export const HK_CONNECTION_PROBE: InjectionKey<HkConnectionProbeSource> =
   Symbol("HkConnectionProbe");
 
@@ -45,7 +63,8 @@ const backendStateColor: Record<HkBackendStatus["state"], string> = {
  * Composes useConnectionProbe + useEngineHealth + useConnectionInfo +
  * HkStatusBar. The probe source is injectable: when a parent provides
  * HK_CONNECTION_PROBE, that probe (and its retryNow) is used verbatim;
- * otherwise hikari's own fetch-poll useConnectionProbe() runs. Slots:
+ * without an injection the shell renders an inert unknown state and
+ * NEVER touches the network (pinned). Slots:
  * - `left`  — extras after the status tags (e.g. a mock badge)
  * - `right` — extras on the far right (e.g. an engine version tag)
  */
@@ -54,19 +73,21 @@ export const HkConnectionStatus = defineComponent({
   props: {
     version: { type: String, default: "0.1.0" },
     panelBuildHash: { type: String as PropType<string | undefined>, default: undefined },
-    /** API origin for the /api/health probe (defaults to same-origin ""). */
-    baseUrl: { type: String as PropType<string | undefined>, default: undefined },
     backendStatus: { type: Object as PropType<HkBackendStatus | undefined>, default: undefined },
     standalone: { type: Boolean, default: true },
     /** Forwarded to HkStatusBar — collapse to the traffic-light dot. */
     compact: { type: Boolean, default: false },
   },
   setup(props, { slots }) {
-    // Probe-source overload: a host app (chest) provides its own
-    // RpcClient-driven probe; everyone else gets hikari's fetch-poll.
+    // SHELL-ONLY: the network side (WHO polls /api/health and HOW)
+    // lives in the host — injected via HK_CONNECTION_PROBE /
+    // HK_ENGINE_HEALTH. Without an injection the shell renders an
+    // inert unknown state and never touches the network (the
+    // fetch-poll defaults were demoted with the chat kit wave).
     const injectedProbe = inject(HK_CONNECTION_PROBE, null);
-    const { result: probe, retryNow } = injectedProbe ?? useConnectionProbe();
-    const { health } = useEngineHealth(props.baseUrl);
+    const probe = injectedProbe?.result ?? ref(INERT_PROBE);
+    const retryNow = injectedProbe?.retryNow ?? (() => {});
+    const health = inject(HK_ENGINE_HEALTH, ref<EngineHealth | null>(null));
 
     const connectionState = computed<ConnectionStateInput>(() => probe.value.state);
     const transportTier = computed(() => probe.value.transportTier);

package/src/components/HkKanban.tsx

@@ -96,6 +96,15 @@ export default defineComponent({
     /** Whether cards can be dragged between lanes. */
     draggable: { type: Boolean, default: false },
     ariaLabel: { type: String, default: undefined },
+    /** Forwarded to the strip's HkScrollContainer: spend the shell-
+     *  published --hk-scroll-tail-bottom as an in-flow tail spacer so a
+     *  dock floating over the board never covers its last row at the
+     *  scroll end (see HkScrollContainer's dockTailClearance). Only
+     *  effective on axis="vertical"/"both" boards: the default
+     *  horizontal axis carries its tail on the cross axis, where the
+     *  contract generates no spacer and the shrink pin is inert in the
+     *  block viewport — a horizontal board gets a no-op by design. */
+    dockTailClearance: { type: Boolean, default: false },
   },
   emits: ["move"],
   setup(props, { slots, emit, expose }) {
@@ -191,6 +200,7 @@ export default defineComponent({
               class="hk-kanban-strip"
               axis={stripAxis.value}
               overscanScreens={1}
+              dockTailClearance={props.dockTailClearance}
             >
               <div
                 class="hk-kanban-lanes"

package/src/components/HkScrollContainer.dock.test.tsx

@@ -8,11 +8,20 @@
 // host so consumers size their content end-padding against the dock
 // without hand-rolled px. The dock-edge fade rides on data-dock-fade.
 //
+// The FLOATING-dock twin (dockTailClearance) is contract-tested below:
+// it spends the shell-published --hk-scroll-tail-bottom as an in-flow
+// tail spacer instead of reserving layout space.
+//
 // House style: raw createApp mounts on shared containers (no
 // @vue/test-utils).
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
 import { afterEach, describe, expect, it } from "vitest";
 import { createApp, h, defineComponent } from "vue";
 
+import HkKanban from "./HkKanban";
 import HkScrollContainer from "./HkScrollContainer";
 
 const mounts: ReturnType<typeof createApp>[] = [];
@@ -90,3 +99,83 @@ describe("HkScrollContainer dock slots", () => {
     expect(host.style.getPropertyValue("--hk-scroll-dock-bottom")).toBe("");
   });
 });
+
+describe("HkScrollContainer floating-dock tail clearance", () => {
+  function mountKanban(props: Record<string, unknown> = {}) {
+    const container = document.createElement("div");
+    document.body.appendChild(container);
+    containers.push(container);
+    const app = createApp(defineComponent({
+      setup() {
+        return () => h(HkKanban, {
+          lanes: [{ id: "a" }, { id: "b" }],
+          laneKeyOf: (lane: unknown) => (lane as { id: string }).id,
+          cardsOf: () => [{ id: "c" }],
+          axis: "vertical",
+          ...props,
+        }, { card: () => h("div", { class: "card" }, "card") });
+      },
+    }));
+    mounts.push(app);
+    return app.mount(container);
+  }
+
+  it("marks the host only while dockTailClearance is on", () => {
+    const on = mountDock({ default: () => h("div", "rows") }, { dockTailClearance: true });
+    expect((on.$el as HTMLElement).getAttribute("data-dock-tail")).toBe("true");
+    const off = mountDock({ default: () => h("div", "rows") });
+    expect((off.$el as HTMLElement).getAttribute("data-dock-tail")).toBeNull();
+  });
+
+  it("forwards through HkKanban onto the strip host", () => {
+    const vm = mountKanban({ dockTailClearance: true });
+    const strip = (vm.$el as HTMLElement).querySelector(".hk-kanban-strip")!;
+    expect(strip.getAttribute("data-dock-tail")).toBe("true");
+    const bare = mountKanban();
+    const bareStrip = (bare.$el as HTMLElement).querySelector(".hk-kanban-strip")!;
+    expect(bareStrip.getAttribute("data-dock-tail")).toBeNull();
+  });
+
+  it("spends the published var on a shrink-safe in-flow spacer (style contract)", () => {
+    // happy-dom has no layout, so the geometry half of the contract is
+    // pinned as a style contract: the spacer trails the viewport's own
+    // content as a `flex: none; display: block` ::after (a column-flex
+    // viewport cannot compress it; the explicit display is what makes
+    // its height apply in the DEFAULT block viewport, where a bare
+    // ::after is an inline box and `height` is inert on it — measured in
+    // a real engine: zero clearance without, content+spacer with), and
+    // EVERY direct child of the viewport is pinned against main-axis
+    // shrinking while the prop is on. The pin is the other load-bearing
+    // half: a child that behaves as a shrinkable flex item once the
+    // viewport is flex-ified (this library's own `.hk-kanban-lanes` ships
+    // only `min-height: 100%`, so the flex-item initial `0 1 auto`
+    // applies) collapses to the viewport height and overflows its rows
+    // visibly, painting them OVER a spacer that trails the box — zero
+    // reachable clearance on any content taller than the viewport while
+    // short content measures green (the defect that kept a consumer
+    // board's tail under its dock through three padding rounds,
+    // root-caused in a real layout engine 2026-10-12). The spacer is
+    // additionally gated OFF axis="horizontal" containers: the tail is
+    // the cross axis there, and an ungated block spacer leaks onto the
+    // hidden vertical axis (measured: scrollHeight +spacer, and a
+    // programmatic scrollTop shifts content up behind
+    // overflow-y:hidden with no wheel path back).
+    const scss = readFileSync(
+      join(dirname(fileURLToPath(import.meta.url)), "HkScrollContainer.scss"),
+      "utf8",
+    );
+    const spacer = scss.match(
+      /\.hk-scroll-container\[data-dock-tail="true"\]:not\(\[data-axis="horizontal"\]\) > \.hk-scroll-container-viewport::after\s*\{[^}]*\}/,
+    );
+    expect(spacer, "tail spacer rule must exist").not.toBeNull();
+    expect(spacer![0]).toMatch(/content:\s*""/);
+    expect(spacer![0]).toMatch(/display:\s*block/);
+    expect(spacer![0]).toMatch(/flex:\s*none/);
+    expect(spacer![0]).toMatch(/height:\s*var\(--hk-scroll-tail-bottom,\s*0px\)/);
+    const pin = scss.match(
+      /\.hk-scroll-container\[data-dock-tail="true"\] > \.hk-scroll-container-viewport > \*\s*\{[^}]*\}/,
+    );
+    expect(pin, "viewport-child shrink pin must exist").not.toBeNull();
+    expect(pin![0]).toMatch(/flex-shrink:\s*0/);
+  });
+});

package/src/components/HkScrollContainer.scss

@@ -84,6 +84,56 @@
   mask-image: linear-gradient(to bottom, transparent, #000 var(--hk-scroll-dock-fade, 2rem));
 }
 
+/* ── Floating-dock tail clearance (dockTailClearance opt-in) ──────
+   A dock that floats OVER the scroll area (shell-level fixed plane —
+   NOT a dockTop/dockBottom slot) covers the viewport's tail. The shell
+   publishes its live measured occupancy as --hk-scroll-tail-bottom;
+   this spends it as an IN-FLOW tail spacer on the viewport's own
+   content, so the room is reachable scroll range that only appears at
+   the scroll end (mid-scroll content keeps flowing under the dock).
+
+   Two halves, both load-bearing (root-caused 2026-10-12 in a real
+   layout engine after three consumer-side padding rounds "never
+   entered the flow"):
+   1. the spacer is a `flex: none` ::after WITH `display: block` — a
+      column-flex viewport cannot compress it (and blockifies it
+      anyway), while in the DEFAULT block viewport the explicit
+      display is what makes its height apply at all: a bare ::after
+      there is a non-replaced INLINE box and `height` is inert on it
+      (measured: block viewport, 300px child, 50px spacer ->
+      scrollHeight 300 without the display, 350 with);
+   2. every direct child of the viewport is pinned against main-axis
+      SHRINKING while the prop is on — a child that behaves as a
+      shrinkable flex item once the viewport is flex-ified
+      (`.hk-kanban-lanes` ships only `min-height: 100%`, so the
+      flex-item initial `0 1 auto` applies) collapses to the viewport
+      height and overflows its rows VISIBLY, painting them over a
+      spacer that trails the box: zero reachable clearance on any
+      content taller than the viewport, while short content (demo
+      boards, empty-ish pages) measures green and hides the defect.
+   The spacer is inert while the var is unset/0px; the shrink pin is
+   active whenever the prop is on (at S=0 it changes only box extent,
+   not scroll range). The spacer is NOT generated on axis="horizontal"
+   containers: there the tail is the cross axis, and an ungated block
+   spacer stacks below the full-height content on the HIDDEN vertical
+   axis (measured: scrollHeight +50, and a programmatic scrollTop
+   shifts the content up behind overflow-y:hidden with no wheel path
+   back). The pin stays ungated (flex-shrink is inert on block children
+   and a no-op on the align-center aligner, which is already
+   flex:none). Consumer note: a higher-specificity consumer ::after
+   recipe on the viewport overrides this spacer's height — adopting
+   the prop means deleting the hand-rolled recipe, not stacking it. */
+.hk-scroll-container[data-dock-tail="true"] > .hk-scroll-container-viewport > * {
+  flex-shrink: 0;
+}
+
+.hk-scroll-container[data-dock-tail="true"]:not([data-axis="horizontal"]) > .hk-scroll-container-viewport::after {
+  content: "";
+  display: block;
+  flex: none;
+  height: var(--hk-scroll-tail-bottom, 0px);
+}
+
 
 .hk-scroll-container[data-fade="true"][data-h-overflow="start"] > .hk-scroll-container-viewport {
   -webkit-mask-image: linear-gradient(to right, transparent 0, #000 var(--hk-scroll-fade-size));

package/src/components/HkScrollContainer.tsx

@@ -85,6 +85,52 @@ export default defineComponent({
      *  scroll content dissolving at the dock's edge reads as
      *  intentional instead of a hard clip. */
     dockFade: { type: Boolean, default: true },
+    /** Opt-in tail clearance for FLOATING docks (2026-10-12): a dock that
+     *  lives OUTSIDE this container (a shell-level fixed plane — a page's
+     *  bottom-center dock bar, e.g. chest's DockBar) covers the bottom of
+     *  whatever scroll area it hovers over. The shell publishes the dock's
+     *  live measured occupancy as `--hk-scroll-tail-bottom` (on any
+     *  ancestor, typically :root); with this prop the container spends
+     *  that var as an IN-FLOW tail spacer on the viewport's own content,
+     *  so the room becomes reachable scroll range that only appears once
+     *  the scroll end is reached — mid-scroll content keeps flowing under
+     *  the dock across the full viewport. The published value is the
+     *  whole tail room the publisher wants spent (dock occupancy plus
+     *  whatever breathing room its design rules add).
+     *
+     *  The spacer is a `flex: none; display: block` ::after, and every
+     *  direct child of the viewport is pinned against main-axis SHRINKING
+     *  while the prop is on. Both halves are load-bearing: a child that
+     *  behaves as a shrinkable flex item once the viewport is flex-ified
+     *  (hikari's own `.hk-kanban-lanes` ships only `min-height: 100%`, so
+     *  the flex-item initial `0 1 auto` applies) overflows its own box
+     *  visibly and paints OVER a spacer that trails the box — the exact
+     *  defect that kept a consumer board's tail under its dock through
+     *  three rounds of padding adjustments that "never entered the flow"
+     *  (chest follow-up to #1538/#1542, root-caused and measured in a real
+     *  layout engine, 2026-10-12); and the explicit `display: block` is
+     *  what makes the spacer's height apply in the DEFAULT block viewport
+     *  at all (a bare ::after there is an inline box and `height` is inert
+     *  on it — measured: zero clearance without, content+spacer with).
+     *  The spacer is inert while the var is unset/0px, so dockless pages
+     *  keep their full centering box; the shrink pin is active whenever
+     *  the prop is on. Unlike the dockTop/dockBottom slots (layout-space
+     *  docks that shrink the viewport permanently), this contract is for
+     *  docks that float OVER the scroll area by design. Do not combine it
+     *  with a `--hk-scroll-dock-bottom` end-padding recipe for the SAME
+     *  dock (double clearance). The spacer is not generated on
+     *  axis="horizontal" containers — the tail is the cross axis there,
+     *  and an ungated block spacer leaks onto the hidden vertical axis
+     *  (measured: scrollHeight grows and a programmatic scrollTop shifts
+     *  content up behind overflow-y:hidden) — while the shrink pin still
+     *  applies. A higher-specificity consumer ::after recipe on the
+     *  viewport overrides this spacer's height: adopting the prop means
+     *  deleting the hand-rolled recipe, not stacking it. The shrink pin's
+     *  accepted cost: a child that legitimately needs main-axis shrink
+     *  inside an opted-in container (a nested pane meant to fit the
+     *  viewport and scroll internally) cannot shrink; consumers escape
+     *  with a >=(0,2,0) override loaded after the library CSS. */
+    dockTailClearance: { type: Boolean, default: false },
     /** Back-to-top signal (scroll parameter every scrollable template
      *  can hand to a floating quick-action pad): while set, the
      *  container derives a visibility signal from its own throttled
@@ -539,6 +585,7 @@ export default defineComponent({
           data-axis={props.axis}
           data-align={alignCenter() ? "center" : undefined}
           data-fade={props.fade ? "true" : undefined}
+          data-dock-tail={props.dockTailClearance ? "true" : undefined}
           data-dock-fade={
             props.dockFade && dockBottomSlot
               ? "bottom"

package/src/components/HkThemeDecor.test.tsx

@@ -175,29 +175,18 @@ describe("HkThemeDecor", () => {
     expect(seen.at(-1)).toMatchObject({ variant: "host", kept: 1 });
   });
 
-  it("lets a theme replace the built-in tray end to end (the TRAY_DECORS replacement path)", async () => {
-    // The per-theme decoration table chest kept inside its tray component is
-    // gone: a theme ships its own tray by registering a component for this
-    // slot under its own id, and hikari's built-in tray answers for every
-    // other theme.
-    registerStandardThemeDecor();
-    const { setTheme } = useTheme();
-    const themedTray = defineComponent({
-      name: "ThemedTray",
-      setup: () => () => h("i", { "data-decor": "themed-tray" }),
+  it("renders a theme tray over the now-empty builtin floor", async () => {
+    // The builtin status.tray floor is EMPTY since the demotion wave —
+    // the default theme package fills it via the "*" wildcard, and any
+    // exact-theme registration wins over that. Here: only the themed
+    // tray renders.
+    const ThemedTray = defineComponent({
+      setup: () => () => h("div", { "data-decor": "themed-tray" }),
     });
-    registerThemeDecor({ themeId: "endfield", slot: "status.tray", component: themedTray });
-
-    const container = mount(h(HkThemeDecor, { slot: "status.tray" }));
-
-    setTheme("endfield");
-    await nextTick();
-    expect(container.querySelector('[data-decor="themed-tray"]')).not.toBeNull();
-    expect(container.querySelector(".s-status-bar-system-tray")).toBeNull();
-
-    setTheme("default");
+    registerThemeDecor({ themeId: "t", slot: "status.tray", component: ThemedTray });
+    useTheme().setTheme("t");
+    const host = mount(h(HkThemeDecor, { slot: "status.tray" }));
     await nextTick();
-    expect(container.querySelector('[data-decor="themed-tray"]')).toBeNull();
-    expect(container.querySelector(".s-status-bar-system-tray")).not.toBeNull();
+    expect(host.querySelector('[data-decor="themed-tray"]')).not.toBeNull();
   });
 });

package/src/components/HkThemeDecor.tsx

@@ -50,7 +50,7 @@ import { useTheme } from "../theme/useTheme";
  * that wants numeric sizing declares its own prop and receives it through
  * `decorProps`.
  *
- * The ladder is the CONTRACT's, not any one decor's: `HkStatusTray`
+ * The ladder is the CONTRACT's, not any one decor's: the default theme's tray
  * implements `sm | md | lg` only, so asking it for `xs` publishes no
  * `--hk-tray-*` var at all and the sheet's `var(--hk-tray-glyph, 9px)`
  * fallbacks render the shipped (md) geometry. That degradation is pinned by

package/src/components/StatusTrayDecor.mount.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, it } from "vitest";
+
+import StatusTrayDecor from "../../../default_theme/src/StatusTrayDecor";
+// The one-import contract under test: importing the package index IS the
+// mount (README: `import "@celestia-island/default-theme"` — CSS + decor).
+import "../../../default_theme/src/index";
+import { getThemeDecor } from "../theme/themeDecor";
+
+/**
+ * @celestia-island/default-theme's delivery mechanism: a bare import of the
+ * package mounts the tray decor on the "*" wildcard via registerThemeDecor,
+ * so every theme (and themeless hosts) resolve it without any host glue.
+ *
+ * This pin lives in the vue suite because default_theme ships no runner of
+ * its own — the vue suite is the only vitest root (CI: ci-hosted.yml) — and
+ * the registry it asserts against is hikari's own. It goes red if the
+ * side-effect call disappears from the package index (the "explicit
+ * mountDefaultTheme()" escape hatch is a replacement, not a supplement).
+ */
+describe("@celestia-island/default-theme side-effect mount", () => {
+  it("a bare import of the package mounts the tray on the '*' wildcard", () => {
+    const resolved = getThemeDecor("status.tray", "any-theme-id");
+    expect(resolved, "status.tray resolves after the bare import").toBeDefined();
+    // And it is THE decor component — not merely some entry — so the
+    // wildcard registration cannot silently drift to another component.
+    expect(resolved?.component).toBe(StatusTrayDecor);
+  });
+
+  it("outranks the builtin floor without touching it (the override path)", () => {
+    // The builtin floor for status.tray is deliberately empty (pinned in
+    // standardDecor.test.ts); the wildcard entry is the ONLY reason the
+    // slot resolves. Same lookup through the star id lands on it too.
+    expect(getThemeDecor("status.tray", "*")?.component).toBe(StatusTrayDecor);
+  });
+});

package/src/components/{HkStatusTray.size.test.ts → StatusTrayDecor.size.test.ts}

@@ -6,7 +6,7 @@ import { compile } from "sass";
 import { describe, expect, it } from "vitest";
 import { createApp, h } from "vue";
 
-import HkStatusTray, { HK_TRAY_SIZE_VARS, type HkStatusTraySize } from "./HkStatusTray";
+import HkStatusTray, { HK_TRAY_SIZE_VARS, type HkStatusTraySize } from "../../../default_theme/src/StatusTrayDecor";
 
 /**
  * The "md is pixel-identical to what already ships" contract.
@@ -18,7 +18,7 @@ import HkStatusTray, { HK_TRAY_SIZE_VARS, type HkStatusTraySize } from "./HkStat
  *
  *   1. the shipped admin-tokens rules (the source of truth),
  *   2. the component's `md` row in HK_TRAY_SIZE_VARS,
- *   3. the fallbacks in HkStatusTray.scss.
+ *   3. the fallbacks in StatusTrayDecor.scss (packages/default_theme).
  *
  * This guard reads (1) out of the COMPILED sheet — not a hand-copied list —
  * and holds (2) and (3) to it, so moving any one of them alone fails here
@@ -67,7 +67,11 @@ function specificity(selector: string): number {
 }
 
 const adminCss = compileSheet(resolve(stylesDir, "admin-tokens.scss"));
-const trayCss = compileSheet(resolve(componentDir, "HkStatusTray.scss"));
+// The tray decor itself lives in packages/default_theme now; the shared
+// sheets it is held against (admin-tokens.scss, scale.scss) stayed here.
+const trayCss = compileSheet(
+  resolve(componentDir, "../../../default_theme/src/StatusTrayDecor.scss"),
+);
 const scaleVars: Record<string, string> = {};
 for (const m of readFileSync(resolve(srcDir, "scale.scss"), "utf8")
   .replace(/\/\*[\s\S]*?\*\//g, "")

package/src/components/{HkStatusTray.test.tsx → StatusTrayDecor.test.tsx}

@@ -2,7 +2,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { createApp, h, nextTick } from "vue";
 
 import { readHkRuntime } from "../runtime/registry";
-import HkStatusTray from "./HkStatusTray";
+import HkStatusTray from "../../../default_theme/src/StatusTrayDecor";
 
 /**
  * HkStatusTray behaviour: the gamepad cluster + clock surface, its size and
@@ -10,7 +10,8 @@ import HkStatusTray from "./HkStatusTray";
  * teardown of both intervals.
  *
  * The "md equals the shipped CSS" contract lives next door in
- * `HkStatusTray.size.test.ts` (it reads the sheets, not the DOM).
+ * `StatusTrayDecor.size.test.ts` (it reads the sheets, not the DOM —
+ * the decor itself lives in packages/default_theme).
  */
 
 const mounts: Array<{ app: ReturnType<typeof createApp>; container: HTMLElement }> = [];

package/src/components/themeDecorLayout.contract.test.ts

@@ -50,7 +50,6 @@ interface Target {
 
 const TARGETS: Target[] = [
   { file: "HkThemeDecor.tsx", anchor: "HkThemeDecor" },
-  { file: "HkStatusTray.tsx", anchor: "s-status-bar-system-tray" },
   { file: "HkStatusTray.scss", anchor: "s-status-bar-system-tray" },
 ];
 
@@ -102,10 +101,11 @@ describe("theme decor layout contract", () => {
   });
 
   it("scans existing files that carry the expected content (no empty scan)", () => {
-    expect(TARGETS.length).toBeGreaterThan(0);
-    for (const { file, anchor } of TARGETS) {
-      const path = resolve(componentDir, file);
-      expect(existsSync(path), `${file} exists`).toBe(true);
+    // The tray decor moved to packages/default_theme (the demotion
+    // wave); only the files still living here are scanned.
+    const present = TARGETS.filter(({ file }) => existsSync(resolve(componentDir, file)));
+    expect(present.length, "at least one target still in-tree").toBeGreaterThan(0);
+    for (const { file, anchor } of present) {
       const source = read(file);
       expect(source.length, `${file} is not empty`).toBeGreaterThan(50);
       expect(source, `${file} carries ${anchor}`).toContain(anchor);
@@ -113,7 +113,7 @@ describe("theme decor layout contract", () => {
   });
 
   it("keeps positioning out of the decor components and their sheets", () => {
-    for (const { file } of TARGETS) {
+    for (const { file } of TARGETS.filter(({ file }) => existsSync(resolve(componentDir, file)))) {
       const hits = positionHits(file, read(file));
       expect(hits, `${file} must not position itself: ${JSON.stringify(hits)}`).toEqual([]);
     }

package/src/composables/engineHealthTypes.ts

@@ -0,0 +1,50 @@
+/** Engine-health DTOs — the SHELL side of the split (the fetch hook
+ * that fills them was demoted to the consuming app with the chat-kit
+ * wave; the shapes stay so HkConnectionStatus's injection contract is
+ * typed here). */
+
+/** Connectivity probe result — the shape a host's injected probe
+ * (HK_CONNECTION_PROBE) exposes. The fetch implementation that
+ * produced it was demoted to the app; the shape stays as the shell's
+ * contract. */
+export interface ProbeResult {
+  connected: boolean;
+  state: "connected" | "disconnected" | "connecting" | "reconnecting" | "failed";
+  /** Canonical transport tier ("local" | "ws" | "sse" | "poll"). */
+  transportTier: string;
+  /** @deprecated Use `transportTier`. Alias kept for compatibility. */
+  tier: string;
+  latencyMs: number | null;
+  /** Canonical 1-based connect-attempt counter. */
+  attemptNumber: number;
+  /** @deprecated Use `attemptNumber`. Alias kept for compatibility. */
+  retryCount: number;
+  retryTotal: number;
+  /** Seconds until the next automatic probe attempt. */
+  countdown: number;
+}
+
+
+/** Inlined subset of the `/api/health` network payload — kept local so
+ *  hikari stays dependency-free of protocol packages. */
+export interface NetworkInfo {
+  transport?: string;
+  region?: string;
+  asn?: number | null;
+}
+
+/** Inlined subset of the `/api/health` response envelope. */
+export interface HealthResponse {
+  engine_version?: string;
+  build_hash?: string;
+  network?: NetworkInfo;
+}
+
+export type { NetworkInfo as EngineNetworkInfo };
+
+/** Subset of `/api/health` relevant to status-bar style consumers. */
+export interface EngineHealth {
+  engineVersion: string | null;
+  engineBuildHash: string | null;
+  network: NetworkInfo | null;
+}

package/src/i18n/usageSurface.test.ts

@@ -122,7 +122,6 @@ function scanSources(): { statics: Site[]; constructed: Site[] } {
  *  every listed family must still exist in source, so this whitelist
  *  cannot rot into silence. */
 const DYNAMIC_KEY_FAMILIES: Record<string, string> = {
-  "hikari::context.": "HkContextRing section keys — closed enum, pinned by name in contextKeys.test.ts.",
   "hikari::statusBar.backend.": "HkConnectionStatus — enumerated connection-state suffixes.",
   "hikari::statusBar.region.": "HkStatusBar region names — OPTIONAL per-locale overrides over Intl.DisplayNames (see LOCALE_SPECIFIC_NESTED in flatKeyParity.test.ts).",
   "hikari::statusBar.tier.": "HkStatusBar transport tiers — constructed into a variable at a distance from its t() call (F1); the four concrete ids are pinned by name in CONSTRUCTED_FAMILY_KEYS below.",