@celestia-island/hikari 0.55.320 → 0.55.321

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celestia-island/hikari",
-  "version": "0.55.320",
+  "version": "0.55.321",
   "private": false,
   "type": "module",
   "description": "Hikari UI library, Vue 3 runtime — one design system for Vue 3 and Rust/WASM applications",

package/src/components/HkBoard.scss

@@ -113,8 +113,16 @@
   inset-inline-end: var(--space-10);
   bottom: var(--space-10);
   z-index: 6;
-  // Defensive re-enable (the inner HkMinimap root asserts it too,
-  // HkMinimap.scss:15): keeps the dock alive if a host ever parks the
-  // board under an ancestor `pointer-events: none`.
+  // Defensive re-enable (the inner HkMinimap root asserts it too, in
+  // HkMinimap.scss's root rule): keeps the dock alive if a host ever
+  // parks the board under an ancestor `pointer-events: none`.
   pointer-events: auto;
 }
+
+// The dock is the ONE anchor (same contract as HkNodeCanvas's): the
+// docked card goes static so the dock's own corner inset is the only
+// one applied — without this the card stacked its self-docking offset
+// on top and sat twice as far from the corner as designed.
+.hk-board-minimap > .hk-minimap {
+  position: static;
+}

package/src/components/HkMinimap.scss

@@ -1,6 +1,13 @@
 @use "../styles/polyfill" as *;
 
 .hk-minimap {
+  // SELF-DOCKING form (position: absolute + corner insets): for hosts
+  // that mount the card DIRECTLY on a positioned surface (HkTreemapStage,
+  // HkBoard3D's minimap3d). Hosts that wrap the card in a positioned DOCK
+  // (HkNodeCanvas's `.hk-node-canvas-minimap`, HkBoard's
+  // `.hk-board-minimap`) reset the card to `position: static` in their
+  // own sheet — the dock owns the corner and the card must not stack a
+  // second absolute offset on top of it (the doubled inset bug).
   position: absolute;
   bottom: var(--space-12);
   // Corner overlay anchor mirrors in RTL like the sibling HkZoomToolbar

package/src/components/HkNodeCanvas.scss

@@ -67,6 +67,16 @@
   inset-inline-start: var(--space-12);
 }
 
+/* The wrapper is the ONE anchor: the docked card goes static so it sizes
+   the wrapper's shrink-to-fit box instead of stacking its own absolute
+   corner offset on top of the wrapper's (the doubled inset read as the
+   map floating oddly far and lopsided from its corner — one inset came
+   from here, a second from `.hk-minimap`'s self-docking rule). Works for
+   every placement: the wrapper's own data-placement carries the corner. */
+.hk-node-canvas-minimap > .hk-minimap {
+  position: static;
+}
+
 /* ── Interactive edges ───────────────────────────────────────────────
    The halo paths are always in the DOM when `interactiveEdges` is on but
    invisible until their edge is hovered or selected, so highlighting

package/src/components/HkNodeCanvas.tsx

@@ -217,7 +217,11 @@ export default defineComponent({
      *  out with `false`. Needs `contentBounds` to know the hull — without
      *  it there is nothing to clamp against and this is a no-op. */
     clampToBounds: { type: Boolean, default: true },
-    /** Mount the minimap in the corner. */
+    /** Mount the minimap in the corner. The slot's card must be a
+     *  DIRECT child of the dock wrapper (`.hk-node-canvas-minimap >
+     *  .hk-minimap` is reset to static — the dock owns the corner inset;
+     *  an intermediate wrapper around the card would re-stack the card's
+     *  own self-docking offset on top of the dock's). */
     minimap: { type: Boolean, default: true },
     /** Which corner the minimap takes. */
     minimapPlacement: {

package/src/components/minimapDock.styles.test.ts

@@ -0,0 +1,82 @@
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { compile } from "sass";
+import { describe, expect, it } from "vitest";
+
+/**
+ * Compiled-stylesheet guard for the minimap DOCK contract: a positioned
+ * dock wrapper (HkNodeCanvas's `.hk-node-canvas-minimap`, HkBoard's
+ * `.hk-board-minimap`) owns the corner inset, and the docked card is
+ * reset to `position: static` so it sizes the dock's shrink-to-fit box.
+ * Without the reset the card stacked its own self-docking absolute
+ * offset (`.hk-minimap`'s bottom + inset-inline-end) on top of the
+ * dock's, and the map sat twice as far from its corner as designed —
+ * measurably lopsided against the undocked axes. Vitest stubs CSS, so
+ * the runtime suites can never catch a lost rule; this reads the
+ * compiled sheet.
+ */
+
+const componentDir = resolve(dirname(fileURLToPath(import.meta.url)));
+
+function compileSheet(name: string): string {
+  return compile(resolve(componentDir, name), { style: "expanded" }).css;
+}
+
+const canvasCss = compileSheet("HkNodeCanvas.scss");
+const boardCss = compileSheet("HkBoard.scss");
+
+function ruleFor(css: string, selector: string): string {
+  const start = css.indexOf(selector);
+  expect(start, `${selector} present in the compiled sheet`).toBeGreaterThanOrEqual(0);
+  const open = css.indexOf("{", start);
+  const close = css.indexOf("}", open);
+  return css.slice(start, close + 1);
+}
+
+describe("minimap dock stylesheet contract", () => {
+  it("HkNodeCanvas's wrapper is the single anchor: the docked card is static", () => {
+    const rule = ruleFor(canvasCss, ".hk-node-canvas-minimap > .hk-minimap");
+    expect(rule).toContain("position: static");
+  });
+
+  it("HkBoard's dock is the single anchor: the docked card is static", () => {
+    const rule = ruleFor(boardCss, ".hk-board-minimap > .hk-minimap");
+    expect(rule).toContain("position: static");
+  });
+
+  it("the docks keep their own corner insets (the anchor that remains)", () => {
+    // The wrapper still carries the placement insets — the static card
+    // has not REPLACED the dock's geometry, only stopped doubling it.
+    // (Compiled attribute selectors lose their quotes: bottom-right.)
+    expect(canvasCss).toContain(".hk-node-canvas-minimap[data-placement=bottom-right]");
+    const dock = ruleFor(boardCss, ".hk-board-minimap");
+    expect(dock).toContain("position: absolute");
+    expect(dock).toContain("inset-inline-end");
+    expect(dock).toContain("bottom");
+  });
+
+  it("the card's self-docking form survives for direct mounts", () => {
+    // TreemapStage / HkBoard3D mount the card directly on a positioned
+    // surface with no dock wrapper — the root rule must keep its own
+    // absolute corner for them.
+    const minimapCss = compileSheet("HkMinimap.scss");
+    const root = ruleFor(minimapCss, ".hk-minimap {");
+    expect(root).toContain("position: absolute");
+  });
+
+  it("the static reset survives sheet read round-trips (no @extend loss)", () => {
+    // The selector is plain and direct (no nesting tricks), so a future
+    // Sass rewrite cannot silently drop it from the compiled output.
+    expect(canvasCss.match(/position: static/g)?.length ?? 0).toBeGreaterThanOrEqual(1);
+    expect(boardCss.match(/position: static/g)?.length ?? 0).toBeGreaterThanOrEqual(1);
+  });
+
+  it("board scss raw source still documents the single-anchor reason", () => {
+    // The WHY lives next to the rule (comments are stripped from the
+    // compiled output, so guard the source text).
+    const src = readFileSync(resolve(componentDir, "HkBoard.scss"), "utf8");
+    expect(src).toContain("ONE anchor");
+  });
+});

package/src/components/sheetfamily-morph-invariant.test.ts

@@ -76,10 +76,18 @@ function flaggedRules(source: string): Array<{ selector: string; body: string }>
   return out;
 }
 
-/** The block's own transition declaration (multi-line shorthands joined). */
-function transitionOf(block: string): string {
-  const match = block.match(/transition:[^;]+;/);
-  return match?.[0]?.replace(/\s+/g, " ").trim() ?? "";
+/** Every transition declaration in the block (multi-line shorthands
+ *  joined, in order). Reading ALL of them closes the coverage hole the
+ *  mutation round proved (H1): a stray second `transition:` declaration
+ *  silently overrides the first in real CSS (last wins), so leg checks
+ *  scoped to the first would pass while the real grammar went rogue.
+ *  The flagged-rule assertions below additionally require EXACTLY one
+ *  declaration — two shorthands in one rule is an authoring hazard the
+ *  mechanical contract refuses outright. */
+function transitionOf(block: string): string[] {
+  return [...block.matchAll(/transition:[^;]+;/g)].map((m) =>
+    m[0].replace(/\s+/g, " ").trim(),
+  );
 }
 
 describe("sheet family morph-flag ↔ transition-grammar contract", () => {
@@ -94,10 +102,15 @@ describe("sheet family morph-flag ↔ transition-grammar contract", () => {
   it("every flagged rule carries a clip-path leg and no dead height/max-height legs", () => {
     for (const sheet of FAMILY_SHEETS) {
       for (const rule of flaggedRules(read(sheet))) {
-        const tr = transitionOf(rule.body);
+        const declarations = transitionOf(rule.body);
+        expect(
+          declarations.length,
+          `${sheet} ${rule.selector} carries exactly one transition declaration (a stray second silently overrides the first in real CSS)`,
+        ).toBe(1);
+        const tr = declarations[0] ?? "";
         expect(tr, `${sheet} ${rule.selector} has a transition`).toContain("clip-path");
         expect(tr, `${sheet} ${rule.selector} height leg is dead in clip mode`).not.toMatch(
-          /\bheight\b/,
+          /(?<!max-)\bheight\b/,
         );
         expect(
           tr,