@celestia-island/hikari 0.55.315 → 0.55.316

package/package.json

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

package/src/animation/registerAnimations.test.ts

@@ -26,7 +26,7 @@ function collectSourceFiles(dir: string): string[] {
     if (entry.isDirectory()) {
       if (p === path.resolve(srcDir, "animation")) continue;
       out.push(...collectSourceFiles(p));
-    } else if (/\.(scss|ts|tsx)$/.test(entry.name) && !/\btest\.[tj]sx?$/.test(entry.name)) {
+    } else if (/\.(scss|ts|tsx)$/.test(entry.name) && !/\.(test|spec)\.[tj]sx?$/.test(entry.name)) {
       out.push(p);
     }
   }

package/src/components/HkListTransition.scss

@@ -179,7 +179,13 @@
    the strip itself is pointer-transparent), and inheritance does not
    beat an explicit auto. The ghost must not take clicks while it sinks:
    a tap opened a popover anchored to the fading element (2026-11-07
-   review). Specificity (0,1,1) outranks the (0,1,0) button faces. */
+   review). Specificity (0,1,1) outranks the (0,1,0) button faces.
+   Belt relationship: pinLeaving also sets `inert` on the ghost (blocks
+   clicks AND focus for every descendant where the pin ran); this rule is
+   the CSS belt that still dead-ends buttons when the pin skipped (no
+   layout — tests — or a host without captured rects). Future surface
+   consumers whose rows carry links/inputs, not just buttons: extend this
+   selector or rely on the inert. */
 .hk-list-surface-leave-active button {
   pointer-events: none;
 }

package/src/components/HkModal.leavepin.test.tsx

@@ -122,7 +122,7 @@ describe("HkModal leave-window height pin", () => {
   it("keeps the morph pin through the whole leave and releases at finalize", async () => {
     vi.useFakeTimers();
     freezeRaf();
-      stubPhoneViewport();
+    stubPhoneViewport();
     stubDurations();
     stubLayout(500);
     try {
@@ -160,7 +160,7 @@ describe("HkModal leave-window height pin", () => {
   it("leaves the frame unpinned through the enter; the open edge pins the settled height", async () => {
     vi.useFakeTimers();
     freezeRaf();
-      stubPhoneViewport();
+    stubPhoneViewport();
     stubDurations();
     stubLayout(400);
     try {
@@ -197,7 +197,7 @@ describe("HkModal leave-window height pin", () => {
   it("drops the held pin at a reopen-interrupt edge; the open edge re-pins", async () => {
     vi.useFakeTimers();
     freezeRaf();
-      stubPhoneViewport();
+    stubPhoneViewport();
     stubDurations();
     stubLayout(500);
     try {

package/src/components/HkModal.open-close-scale.test.ts

@@ -378,6 +378,24 @@ describe("HkModal desktop open/close contract (compiled cascade, user direction
     }
   });
 
+  it("keeps the desktop rest transition to the height leg only", () => {
+    // The size morph's height leg is the ONLY property the desktop rest
+    // state ever animates. The clip-path reveal morph belongs to the
+    // ≤767px sheet block (which replaces the list wholesale), and
+    // nothing changes the frame's max-height after mount (the 70vh cap
+    // is the body's, a different element) — retired legs smuggled back
+    // into the shorthand must fail this pin (2026-11-07 residue sweep).
+    const rest = frameWith();
+    expect(winner(rest, "transition", DESKTOP)).toBe(
+      "height var(--duration-fast, 0.15s) var(--ease-standard, cubic-bezier(0.4, 0, 0.2, 1))",
+    );
+    // The phone sheet keeps its own clip-path-only morph list.
+    const mobileRest = frameWith();
+    expect(winner(mobileRest, "transition", MOBILE)).toBe(
+      "clip-path var(--hk-modal-morph-duration, 0.3s) var(--ease-standard, cubic-bezier(0.4, 0, 0.2, 1))",
+    );
+  });
+
   it("fades the frame and rides its height on one shared token pair per direction", () => {
     // Pinned WHOLE (winner() normalizes whitespace), not by prefix: a
     // fourth time value (transition-delay) or an extra smuggled segment

package/src/components/HkModal.scss

@@ -74,14 +74,13 @@
   // (capped) height and pins it as px on every content change — the
   // transition below animates old→new px. Both pinned values are
   // explicit px, so this needs no interpolate-size keyword support.
-  // clip-path rides the same token pair for the mobile sheet's reveal
-  // morph (--hk-sheet-morph: clip below): the pin lands instantly and
-  // the top edge sweeps up paint-only — no per-frame layout, no
-  // per-frame backdrop re-raster over the resizing fixed layer.
-  transition:
-    height var(--duration-fast, 0.15s) var(--ease-standard, cubic-bezier(0.4, 0, 0.2, 1)),
-    max-height var(--duration-fast, 0.15s) var(--ease-standard, cubic-bezier(0.4, 0, 0.2, 1)),
-    clip-path var(--duration-fast, 0.15s) var(--ease-standard, cubic-bezier(0.4, 0, 0.2, 1));
+  // Height is the only leg the desktop rest state ever animates: the
+  // clip-path reveal morph belongs to the ≤767px sheet block (which
+  // replaces this list wholesale), and on desktop nothing — hikari or
+  // host — changes the frame's max-height after mount (the 70vh cap is
+  // the body's, a different element; the phone caps move by design and
+  // deliberately carry no leg — see the IME cap-chase note below).
+  transition: height var(--duration-fast, 0.15s) var(--ease-standard, cubic-bezier(0.4, 0, 0.2, 1));
   background: var(--hk-modal-bg, var(--hi-color-surface, rgba(255,255,255,0.95)));
   @include backdrop-filter(var(--hk-modal-blur, none));
   border: 1px solid var(--hk-modal-border-color, var(--hi-color-border, rgba(100,100,100,0.08)));
@@ -483,7 +482,7 @@
     //   direction change. Growth keeps its animated reveal via the
     //   clip-path sweep (the only transition left on phones).
     //
-    // Desktop keeps the full base list (height + max-height + clip-path).
+    // Desktop keeps the base list (height only — the size morph's leg).
     // 0.3s = the stepflow crossfade's family standard (2026-09-21 user
     // spec, round 7): the clip sweep, the riding body and the fade must
     // land together. Keyboard-driven height changes never animate

package/src/components/HkModal.sheetgap.test.ts

@@ -114,16 +114,21 @@ describe("HkModal mobile sheet spacing contract", () => {
       expect(tr).not.toMatch(/\bmax-height\b/);
     });
 
-    it("keeps the desktop frame transition list intact (base rule)", () => {
-      // The guard is phone-only by design: the base rule outside the
-      // media block keeps height+max-height+clip-path animated.
+    it("keeps the desktop frame transition to the height leg only (base rule)", () => {
+      // The guard is phone-only by design: outside the media block the
+      // base rule animates height only — the size morph's leg. The
+      // clip-path reveal lives in the ≤767px block (which replaces the
+      // list wholesale), and nothing changes the frame's max-height
+      // after mount (the 70vh cap is the body's, a different element):
+      // the 2026-11-07 residue sweep retired the never-animated
+      // max-height/clip-path legs, and this pin keeps them retired.
       const base = src.match(/\.hk-modal-content\s*{[^}]*}/)?.[0] ?? "";
       expect(base.length, "base .hk-modal-content rule extracted").toBeGreaterThan(0);
       const tr = base.match(/transition:\s*([^;]+);/)?.[1] ?? "";
       expect(tr.length, "base transition declaration present").toBeGreaterThan(0);
       expect(tr).toMatch(/\bheight\b/);
-      expect(tr).toMatch(/\bmax-height\b/);
-      expect(tr).toMatch(/\bclip-path\b/);
+      expect(tr).not.toMatch(/\bmax-height\b/);
+      expect(tr).not.toMatch(/\bclip-path\b/);
     });
 
     it("lifts the 70vh body cap on phones so the footer sits on the bottom edge", () => {

package/src/components/HkModal.sheetmorph.test.ts

@@ -11,9 +11,11 @@
  *   - growth morphs REVEAL through clip-path (--hk-sheet-morph: clip on
  *     the docking surfaces, useSizeMorph does the pin-instantly +
  *     sweep-up dance) — paint/compositor-level, zero per-frame layout;
- *     the frame stylesheet carries the clip-path transition on the SAME
- *     duration/ease tokens as the height transition, so the stretch look
- *     and its reduced-motion / data-css-animations governance are intact
+ *     the ≤767px sheet block replaces the frame's transition list
+ *     wholesale and carries the clip-path transition retimed to the
+ *     stepflow family standard, so the stretch look and its
+ *     reduced-motion / data-css-animations governance are intact (the
+ *     desktop base list animates the size morph's height leg only)
  *   - docked phone surfaces NEVER backdrop-filter (mobile-guard tokens
  *     defaulting to none: --hk-modal-blur-mobile, --hk-modal-overlay-
  *     blur-mobile, --hk-drawer-blur-mobile, --hk-drawer-overlay-blur-
@@ -54,12 +56,17 @@ describe("sheet family morph-performance contract", () => {
     expect(mobileModal).toMatch(/^[ \t]*--hk-sheet-morph:[ \t]*clip;$/m);
   });
 
-  it("carries a clip-path transition on the morph timing tokens", () => {
-    // Same duration/ease pair as the height morph — the reveal must keep
-    // the stretch look, not invent new timing.
+  it("keeps the clip sweep on the sheet block, out of the desktop base list", () => {
+    // 2026-11-07 residue sweep: the desktop rest state never sweeps a
+    // clip-path (no clip-mode surface exists ≥768px), so the base list
+    // carries the size morph's height leg only. The reveal grammar lives
+    // in the ≤767px block, which replaces the frame's transition list
+    // wholesale and retimes the sweep to the stepflow family standard
+    // (pinned by the next test).
     const frame = modal.match(/\.hk-modal-content\s*{[^}]*}/)?.[0] ?? "";
+    expect(frame).not.toMatch(/^[ \t]*clip-path var\(--duration-fast/m);
     expect(frame).toMatch(
-      /^[ \t]*clip-path var\(--duration-fast, 0\.15s\) var\(--ease-standard, cubic-bezier\(0\.4, 0, 0\.2, 1\)\);$/m,
+      /^[ \t]*transition: height var\(--duration-fast, 0\.15s\) var\(--ease-standard, cubic-bezier\(0\.4, 0, 0\.2, 1\)\);$/m,
     );
   });
 

package/src/composables/useSizeMorph.test.ts

@@ -743,10 +743,12 @@ describe("useSizeMorph clip reveal", () => {
 // ── Leave-window hold + enter-window defer (2026-09-16 modal report) ──
 // The modal's close fold owns the frame's geometry for the whole leave:
 // hold() keeps the pin (a mid-leave content change must not resize the
-// folding frame) and the reopen-interrupt path animates FROM that pin.
-// The enter unfold is height-relative geometry (translateY 5% + bottom
-// 10% clip of the frame height), so deferRemeasure freezes resize-driven
-// re-pins through the enter and the open edge flushes them.
+// folding frame); a reopen that goes hold → start without releasing
+// animates from that pin (no current HkModal path does this — its reopen
+// edge releases first). deferRemeasure is the generic freeze gate: while
+// it returns true, resize-driven re-pins are deferred and an explicit
+// remeasure() flushes them — HkModal's only remaining freezer is the
+// stepflow slide window.
 
 describe("useSizeMorph hold + deferRemeasure", () => {
   it("hold keeps the pin and stops observing (leave-window stability)", () => {
@@ -790,14 +792,15 @@ describe("useSizeMorph hold + deferRemeasure", () => {
     // The initial pin is NOT gated (arming must pin immediately).
     expect(h.frame.style.height).toBe("120px");
 
-    // Content streams in mid-enter: the RO fires but the pin must not
-    // move — the unfold's height-relative geometry stays put.
+    // Content changes while the gate is closed: the RO fires but the pin
+    // must not move — the caller froze the frame on purpose (the
+    // stepflow slide window at the consumer).
     h.setNatural(160);
     FakeResizeObserver.instances[0]!.callback();
     await settle();
     expect(h.frame.style.height).toBe("120px");
 
-    // The open edge flushes the deferred growth.
+    // An explicit remeasure bypasses the gate and flushes the growth.
     h.remeasure();
     expect(h.frame.style.height).toBe("160px");
 

package/src/composables/useSizeMorph.ts

@@ -35,12 +35,16 @@ export interface SizeMorph {
   /** Arm the morph: observe the content and pin the frame's natural
    *  height on every change. Call once the surface finished its open
    *  enter — the enter must own the frame's geometry (HkModal and
-   *  HkSelectPanel both arm at the machine's `open` edge; the enter
-   *  classes are off the frame by then, so calibration reads the rest
-   *  state). There is no early-arm protocol anymore: the modal's enter
-   *  is opacity+transform and never reads the frame's height, so an
-   *  enter-time pin would only freeze a stale height under
-   *  `overflow: hidden`. */
+   *  HkSelectPanel both arm at the machine's `open` edge). The call may
+   *  land one render flush before the enter classes actually leave the
+   *  frame (the machine flips the phase synchronously, Vue re-renders on
+   *  the next flush); that is safe because no enter class carries layout
+   *  rules that differ from rest — the choreographies are
+   *  opacity+transform, and the ≤767px from-pair's `height: auto`
+   *  coincides with the unpinned rest height — so calibration still
+   *  reads the rest geometry. There is no early-arm protocol anymore:
+   *  the modal's enter never reads the frame's height, so an enter-time
+   *  pin would only freeze a stale height under `overflow: hidden`. */
   start(): void;
   /** Disarm the morph and release the frame to `height: auto` — call
    *  before a surface's leave/close so the exit animation owns the
@@ -56,7 +60,13 @@ export interface SizeMorph {
    *  does this, its reopen edge releases the pin first; held content is unchanged, delta
    *  zero; a re-pin to a CHANGED natural while an enter's transition
    *  classes own the frame lands without a height animation, i.e. snaps
-   *  — acceptable, the enter's own choreography owns that moment). */
+   *  — acceptable, the enter's own choreography owns that moment).
+   *  Recorded design note: a close during an ENTER that never reached
+   *  `open` finds the morph disarmed (hold() early-returns) and the
+   *  leave folds on the live `height: auto` — the same unpinned grammar
+   *  the enter plays, and preferable to folding on a stale mount-time
+   *  pin. contentHold freezes the rendered leaf state at closingFrom, so
+   *  only a self-updating child could resize such a fold. */
   hold(): void;
   /** Drop the height pin and hand the frame back to `height: auto`
    *  without disarming anything (a hold()ed morph stays disarmed; an
@@ -177,7 +187,9 @@ export interface SizeMorphOptions {
  * shrink animation the clip-path-only transition list had lost
  * (2026-09-21 chest report, round 5) without reintroducing a frame of
  * per-frame layout. The layer promotion is RESIDENT for the whole arm
- * cycle (applied at start(), cleared on hold/release): promoting at the
+ * cycle (applied at start(), cleared by hold() at the close request; a
+ * mid-cycle release() — the contamination guard's re-pin —
+ * deliberately keeps it, see release()): promoting at the
  * step-change moment cost a one-frame see-through as the old layer died
  * before the new one rastered (same report).
  * Height-mode surfaces (desktop) keep the height morph unchanged.
@@ -233,7 +245,9 @@ export function useSizeMorph(
    *  normal close. */
   let revealWatchdog: ReturnType<typeof setTimeout> | null = null;
   /** Resident layer promotion on clip-mode surfaces: applied at arm time
-   *  and cleared on hold/release. Promoting at the STEP-change moment
+   *  and cleared by hold() at the close request (a mid-cycle release() —
+   *  the contamination guard's re-pin — deliberately leaves it for the
+   *  cycle to unwind, see clearResidentWill's callers). Promoting at the STEP-change moment
    *  (0.55.38's per-sweep will-change) destroyed the old layer one frame
    *  before the new one had rastered — on the phone GPU the sheet read
    *  as a one-frame see-through flash exactly when the raster race had