@celestia-island/hikari 0.55.312 → 0.55.313

package/package.json

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

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

@@ -15,7 +15,7 @@ import HkModal from "./HkModal";
  *
  * happy-dom has no layout engine, so the frame's offsetHeight is stubbed
  * at the HTMLElement prototype level BEFORE mount — the morph's
- * openingFrom-tick arm then measures 500px and pins it, and every
+ * open-edge arm then measures 500px and pins it, and every
  * mid-leave assertion reads the inline height string directly.
  */
 const mounts: ReturnType<typeof createApp>[] = [];
@@ -128,7 +128,7 @@ describe("HkModal leave-window height pin", () => {
     try {
       const rig = await mountRig();
 
-      // Open to rest: the enter-edge arm measured 500px and pinned it.
+      // Open to rest: the open-edge arm measured 500px and pinned it.
       rig.open.value = true;
       await vi.advanceTimersByTimeAsync(600);
       expect(rig.frameEl()).not.toBeNull();
@@ -157,7 +157,7 @@ describe("HkModal leave-window height pin", () => {
     }
   });
 
-  it("flushes growth deferred through the enter with an open-edge remeasure", async () => {
+  it("leaves the frame unpinned through the enter; the open edge pins the settled height", async () => {
     vi.useFakeTimers();
     freezeRaf();
       stubPhoneViewport();
@@ -166,24 +166,65 @@ describe("HkModal leave-window height pin", () => {
     try {
       const rig = await mountRig();
 
-      // Open: the enter-edge arm pins the enter-time height (400px).
+      // Open: nothing arms during the enter — the frame stays height:auto
+      // so content that streams in mid-enter reflows it live instead of
+      // sitting clipped behind a mount-time pin (2026-11-07 chest report:
+      // topic windows fetched their detail mid-enter and the bottom of
+      // the window stayed missing for the whole open animation).
       rig.open.value = true;
       await vi.advanceTimersByTimeAsync(150); // mid-enter, past the flip
-      expect(rig.pinHeight()).toBe("400px");
+      expect(rig.frameEl()).not.toBeNull();
+      expect(rig.pinHeight()).toBe("");
 
-      // Content grows mid-enter — with the enter's defer gate the pin
-      // must NOT chase it (the choreography's height-relative geometry
-      // stays put; in a real browser the RO fires and is deferred too).
+      // Content grows mid-enter: still unpinned — the growth IS the
+      // frame (auto height follows it frame-by-frame).
       layoutH = 700;
       await vi.advanceTimersByTimeAsync(50);
-      expect(rig.pinHeight()).toBe("400px");
+      expect(rig.pinHeight()).toBe("");
 
-      // The open edge flushes the deferred growth one tick after the
-      // transition classes clear — the pin lands at the grown height.
+      // The open edge pins the settled natural height directly — no
+      // deferred flush, no second growth spurt after the enter.
       await vi.advanceTimersByTimeAsync(450);
       expect(rig.pinHeight()).toBe("700px");
 
-      // Sanity: the surface really rested open before the flush assertion.
+      // Sanity: the surface really rested open before the pin assertion.
+      expect(rig.frameEl()).not.toBeNull();
+    } finally {
+      restoreLayout();
+    }
+  });
+
+  it("drops the held pin at a reopen-interrupt edge; the open edge re-pins", async () => {
+    vi.useFakeTimers();
+    freezeRaf();
+      stubPhoneViewport();
+    stubDurations();
+    stubLayout(500);
+    try {
+      const rig = await mountRig();
+
+      // Open to rest (the open-edge arm pins 500px), then request a
+      // close: the leave holds the pin (the fold owns the frame).
+      rig.open.value = true;
+      await vi.advanceTimersByTimeAsync(600);
+      expect(rig.pinHeight()).toBe("500px");
+      rig.open.value = false;
+      await vi.advanceTimersByTimeAsync(150); // mid-leave
+      expect(rig.frameEl()).not.toBeNull();
+      expect(rig.pinHeight()).toBe("500px");
+
+      // Reopen mid-leave: the reopening edge must DROP the held pin —
+      // otherwise the reopen enter plays at the OLD content's height and
+      // clips whatever the new content renders (the sibling of the
+      // first-open bug this suite retired).
+      rig.open.value = true;
+      await vi.advanceTimersByTimeAsync(150); // mid-reopen-enter
+      expect(rig.frameEl()).not.toBeNull();
+      expect(rig.pinHeight()).toBe("");
+
+      // The open edge re-pins at rest (content unchanged → same height).
+      await vi.advanceTimersByTimeAsync(450);
+      expect(rig.pinHeight()).toBe("500px");
       expect(rig.frameEl()).not.toBeNull();
     } finally {
       restoreLayout();

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

@@ -456,14 +456,21 @@ describe("HkModal rides its chrome and gates the slide window", () => {
     stubClip();
     stubBox(500, Number.POSITIVE_INFINITY);
     stubPhoneViewport();
-    const roInstances: Array<{ callback: () => void }> = [];
+    const roInstances: Array<{ callback: () => void; target: Element | null }> = [];
+    // Select the morph's observer by its OBSERVED TARGET, never by index:
+    // the overlay scrollbar attaches its own ResizeObserver at the mounted
+    // flip, and since the morph arms at the `open` edge (after the enter)
+    // the scrollbar's observer registers first.
+    const morphRo = () =>
+      roInstances.find((ro) => ro.target?.classList.contains("hk-modal-body-inner"))!;
     vi.stubGlobal("ResizeObserver", class {
       callback: () => void;
+      target: Element | null = null;
       constructor(cb: () => void) {
         this.callback = cb;
         roInstances.push(this);
       }
-      observe() {}
+      observe(el: Element) { this.target = el; }
       disconnect() {}
     });
     const rig = await mountRig();
@@ -477,7 +484,7 @@ describe("HkModal rides its chrome and gates the slide window", () => {
     rig.announceSwap({ delta: 0, durationMs: 300, phase: "swap" });
     await nextTick();
     content = 560;
-    roInstances[0]!.callback();
+    morphRo().callback();
     await vi.advanceTimersByTimeAsync(400);
     expect(frame.style.height).toBe("596px");
 
@@ -506,14 +513,19 @@ describe("HkModal rides its chrome and gates the slide window", () => {
     stubClip();
     stubBox(500, Number.POSITIVE_INFINITY);
     stubPhoneViewport();
-    const roInstances: Array<{ callback: () => void }> = [];
+    const roInstances: Array<{ callback: () => void; target: Element | null }> = [];
+    // Same target-based selection as the safety-timer test: the scrollbar's
+    // observer registers before the morph's open-edge arm.
+    const morphRo = () =>
+      roInstances.find((ro) => ro.target?.classList.contains("hk-modal-body-inner"))!;
     vi.stubGlobal("ResizeObserver", class {
       callback: () => void;
+      target: Element | null = null;
       constructor(cb: () => void) {
         this.callback = cb;
         roInstances.push(this);
       }
-      observe() {}
+      observe(el: Element) { this.target = el; }
       disconnect() {}
     });
     // No rAF stub: happy-dom maps rAF onto its timer queue, so the
@@ -528,7 +540,7 @@ describe("HkModal rides its chrome and gates the slide window", () => {
     rig.announceSwap({ delta: 0, durationMs: 300, phase: "swap" });
     await nextTick();
     content = 560;
-    roInstances[0]!.callback();
+    morphRo().callback();
     await vi.advanceTimersByTimeAsync(700);
     expect(frame.style.height).toBe("596px");
 
@@ -540,7 +552,7 @@ describe("HkModal rides its chrome and gates the slide window", () => {
     // Harness validity + unfreeze proof: the SAME observer path now
     // moves the pin without any event.
     content = 700;
-    roInstances[0]!.callback();
+    morphRo().callback();
     await vi.advanceTimersByTimeAsync(700);
     expect(frame.style.height).toBe("796px");
     restoreBox();

package/src/components/HkModal.tsx

@@ -284,24 +284,27 @@ export default defineComponent({
     const innerRef = ref<HTMLElement>();
     // Content-driven size morphing: the frame follows content growth with
     // the height transition instead of snapping (see useSizeMorph). The
-    // gate freezes resize-driven re-measurement through the enter unfold:
-    // the choreography's geometry is height-relative (translateY 5% +
-    // bottom-10% clip of the frame height), so content streaming in
-    // mid-enter would otherwise recompute the pixel geometry under the
-    // running animation (2026-09-16 chest field report — the frame
-    // snapped 459→697px mid-unfold). The open phase edge flushes the
-    // deferred growth with an animated remeasure.
-    // The freeze flag (round 16): while a stepflow SLIDE is in flight the
-    // sheet's height must not chase the flow's changing cell — the gate
-    // below also returns true then, and the morph window's own event
-    // flushes the frozen change with an explicit remeasure.
+    // morph arms at the machine's `open` edge only — never during the
+    // enter. Under the current whole-window zoom+rise choreography the
+    // open animation is opacity+transform on the frame: nothing about it
+    // reads the frame's height, so an enter-time pin has nothing left to
+    // protect, and pinning during the enter would freeze the frame at the
+    // mount-time height while `overflow: hidden` clips whatever content
+    // streams in behind it (2026-11-07 chest report — topic windows
+    // fetched their detail mid-enter and read as "the bottom of the
+    // window is missing" for the whole open animation, then grew). The
+    // old arm-and-freeze existed for the retired height-relative unveil
+    // (translateY fraction + bottom clip of the frame height), whose
+    // geometry a mid-enter resize would have corrupted; that grammar is
+    // gone, so the freeze is gone with it.
+    // The freeze flag (round 16) stays: while a stepflow SLIDE is in
+    // flight the sheet's height must not chase the flow's changing cell —
+    // the gate below also returns true then, and the morph window's own
+    // event flushes the frozen change with an explicit remeasure.
     let swapFrozen = false;
     let swapFreezeTimer: ReturnType<typeof setTimeout> | null = null;
     const morph = useSizeMorph(contentRef, innerRef, {
-      deferRemeasure: () =>
-        swapFrozen ||
-        machine.phase.value === "openingFrom" ||
-        machine.phase.value === "openingTo",
+      deferRemeasure: () => swapFrozen,
       // The sheet's chrome and content block ride the fold edge in
       // lockstep with the clip sweep: the title bar glides with the edge
       // instead of being sliced by it mid-sweep, the content block starts
@@ -593,26 +596,32 @@ export default defineComponent({
             backGuard.push();
           }
           surfTrack.run();
-          // Arm the size morph WITH the enter (one tick later, once the
-          // mounting patch landed): the pin locks the frame's height for
-          // the whole unfold so late-streaming content cannot move the
-          // choreography mid-flight (see the morph's gate above). The
-          // zero-duration fast paths reach `open` before the tick — the
-          // open branch's own start() covers them.
-          void nextTick(() => {
-            const p = machine.phase.value;
-            if (p !== "openingFrom" && p !== "openingTo") return;
-            if (p === "openingFrom" || p === "openingTo") morph.start();
-          });
+          // No morph arm here, on purpose: the enter is opacity+transform
+          // (whole-window zoom+rise), which never reads the frame's
+          // height — the frame stays at `height: auto` so content that
+          // streams in mid-enter reflows it live instead of being clipped
+          // behind a stale mount-time pin (see the morph gate above). The
+          // size morph arms once, at the `open` edge below.
+          // A REOPEN-INTERRUPT (OPEN mid-close) lands here too: the close
+          // request held the previous cycle's pin (morph.hold(), so the
+          // fold played on a stable box) and nothing else would drop it —
+          // the reopen enter would then play pinned at the OLD content's
+          // height, clipping new content exactly like the first-open bug
+          // this file retired. Release the pin so every enter — first or
+          // interrupted — starts at `height: auto`; the hold-kept pin's
+          // other purpose (the close completing) is served by the
+          // finalize edge's own release.
+          morph.release();
         } else if (to === "open") {
           surfTrack.cancel();
           onAfterEnter();
-          // Idempotent re-arm for the fast paths (see openingFrom).
+          // The ONLY morph arm (see the openingFrom note): the enter has
+          // landed, so calibrating and pinning here measures the frame at
+          // rest — with the enter classes no longer in play one tick
+          // later, the follow-up remeasure re-checks the natural height
+          // under the base height transition (a growth that landed in the
+          // last tick of the enter animates instead of snapping).
           morph.start();
-          // Flush the growth deferred through the unfold. One tick later
-          // the transition classes are off the frame, so the base height
-          // transition animates the pin change instead of the enter's
-          // opacity/transform-only transition list swallowing it as a snap.
           void nextTick(() => {
             if (machine.phase.value === "open") morph.remeasure();
           });

package/src/composables/useSizeMorph.ts

@@ -34,10 +34,13 @@ const REVEAL_WARMUP_FRAMES = 2;
 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 transition — pinning during enter would override the
-   *  choreography's own height animation. (Surfaces whose enter is
-   *  height-INDEPENDENT — HkModal's clip+transform unfold — may arm
-   *  earlier with a `deferRemeasure` gate, see below.) */
+   *  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`. */
   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
@@ -48,12 +51,20 @@ export interface SizeMorph {
    *  choreography owns the frame's geometry through the whole leave and
    *  the pin keeps it stable (a mid-leave content change must not resize
    *  the folding frame). The next start() re-arms and, because the pin
-   *  was kept, a re-pin to the SAME natural height is a no-op (the
-   *  typical reopen-interrupt case — held content is unchanged, delta
+   *  was kept, a re-pin to the SAME natural height is a no-op (a reopen
+   *  that goes hold → start without releasing — no current HkModal path
+   *  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). */
   hold(): void;
+  /** Drop the height pin and hand the frame back to `height: auto`
+   *  without disarming anything (a hold()ed morph stays disarmed; an
+   *  armed one keeps observing). In-flight reveals are torn down first,
+   *  exactly like stop(). This is the reopen-interrupt edge's tool: a
+   *  reopen enter must not inherit the previous cycle's pin, or new
+   *  content sits clipped behind the old height for the whole enter. */
+  release(): void;
   /** Re-measure and pin now (resize events, open flows). */
   remeasure(): void;
   /** Plain CSS height morph (round 18): transition the frame's pin
@@ -69,13 +80,14 @@ export interface RideEntry {
 
 export interface SizeMorphOptions {
   /** While this returns true, resize-driven re-measurements are deferred
-   *  (the current pin stays). HkModal freezes the frame's height during
-   *  the enter unfold: the choreography's translateY(5%) + bottom-10%
-   *  clip are fractions of the frame height, so late-streaming content
-   *  resizing the frame mid-enter would recompute the geometry under the
-   *  running animation (2026-09-16 chest field report — the frame snapped
-   *  459→697px mid-unfold). The caller flushes the deferred growth with
-   *  an explicit remeasure() at the open edge. */
+   *  (the current pin stays). HkModal freezes the frame's height while a
+   *  stepflow SLIDE is in flight: the sheet must not chase the flow's
+   *  changing cell mid-slide, and the slide's morph event flushes the
+   *  frozen change with an explicit remeasure once the content settles.
+   *  (The gate used to also cover the modal's own enter — that open
+   *  choreography is opacity+transform today and never reads the frame's
+   *  height, so the enter arms nothing and defers nothing; see the morph
+   *  note in HkModal.) */
   deferRemeasure?: () => boolean;
   /** Fold riders (2026-09-23 round-14 chest report): elements collected
    *  when a clip sweep is STAGED whose translateY must track the sweep's
@@ -623,13 +635,12 @@ export function useSizeMorph(
    *  finished) frame — the only moment guaranteed free of transition-class
    *  flex rules. Never calibrate from a remeasure sample: the first
    *  remeasure can itself be the contaminated one (a frozen enter leaves
-   *  the flex rules behind when the surface is mid-repair). HkModal's
-   *  reopen-interrupt arm violates the precondition on purpose (it
-   *  calibrates a pinned, enter-classed frame): benign today because no
-   *  current enter/leave class carries height/flex rules (the inline pin
-   *  beats the mobile sheet's static height:auto), and the contamination
-   *  guard below degrades any future SCSS regression to a dropped pin
-   *  rather than a corrupted one. */
+   *  the flex rules behind when the surface is mid-repair). Every current
+   *  consumer arms at the machine's `open` edge, on a resting frame. If a
+   *  future caller ever arms earlier (mid-enter), this precondition is
+   *  violated by construction and the contamination guard below degrades
+   *  the bad sample to a dropped pin rather than a corrupted one — it
+   *  does not make early arming correct. */
   function calibrate(): void {
     const f = frame.value;
     const c = content.value;
@@ -834,9 +845,9 @@ export function useSizeMorph(
   }
 
   function onResize(): void {
-    // Frozen window (e.g. HkModal's enter unfold): keep the current pin;
-    // the caller flushes the accumulated change with an explicit
-    // remeasure() once the choreography hands the height back.
+    // Frozen window (HkModal's stepflow SLIDE freeze — the only defer
+    // gate left): keep the current pin; the morph event flushes the
+    // accumulated change with an explicit remeasure.
     if (options.deferRemeasure?.()) return;
     // Debounce the choreography: content can change in a burst (a list
     // transition shrinking rows over several frames, a textarea growing
@@ -1076,5 +1087,5 @@ export function useSizeMorph(
     setTimeout(restore, durationMs + 350);
   }
 
-  return { start, stop, hold, remeasure, heightMorph };
+  return { start, stop, hold, release, remeasure, heightMorph };
 }