@celestia-island/hikari 0.55.64 → 0.55.65

package/package.json

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

package/src/composables/useSizeMorph.test.ts

@@ -1268,4 +1268,71 @@ describe("useSizeMorph heightMorph (round 18)", () => {
     expect(h.frame.style.transition).toBe("");
     h.stop();
   });
+
+  it("does not replay a clip conceal for the settle transient after a shrink morph", async () => {
+    // Round-21 mechanism (rig REPORT-R21-shrink): a stepflow shrink's
+    // heightMorph targets the natural height measured the instant the slide
+    // settled — e.g. 503 — which sits a few px off the frame's settled rest
+    // height (483; the chrome-allowance transient, the long-standing +20px
+    // drift). The observer's settle-debounced remeasure then read that
+    // residual as a fresh shrink and replayed a CLIP CONCEAL ~152ms into
+    // the morph — re-promoting the riders and sweeping a moving edge for
+    // 300ms, which is the shrink-time flash the phone kept reporting. The
+    // remeasure must DEFER for the morph's duration, and the morph's
+    // restore must absorb the drift silently (snap the pin to the settled
+    // height, no clip sweep, no rider re-promotion).
+    const rider = document.createElement("div");
+    const h = mountHarness(786, 366, {
+      collectRide: () => [{ el: rider }],
+    });
+    h.frame.style.setProperty("--hk-sheet-morph", "clip");
+    h.content.appendChild(rider);
+    h.start();
+    expect(h.frame.style.height).toBe("786px");
+    expect(rider.style.willChange).toBe("transform");
+
+    // The shrink morph: natural reads 503 at the settle instant.
+    h.setNatural(503);
+    h.heightMorph(300);
+    expect(h.frame.style.height).toBe("503px");
+    expect(h.frame.style.transition).toContain("height");
+    expect(h.frame.hasAttribute("data-hk-morphing")).toBe(true);
+    expect(rider.style.willChange).toBe("");
+
+    // Mid-morph the transient resolves: the settled rest height is 483.
+    // The observer fires on the content change — it must NOT start a clip
+    // conceal against the running morph.
+    h.setNatural(483);
+    FakeResizeObserver.instances[0]!.callback();
+    await settle();
+    // No clip was staged and the rider was NOT re-promoted: the remeasure
+    // deferred instead of replaying a conceal.
+    expect(h.frame.style.clipPath).toBe("");
+    expect(rider.style.willChange).toBe("");
+    // The morph's own height transition is untouched (still running to 503).
+    expect(h.frame.style.transition).toContain("height");
+    expect(h.frame.hasAttribute("data-hk-morphing")).toBe(true);
+
+    // The morph's transition completes: restore absorbs the drift — the pin
+    // snaps to the settled 483 silently, with no clip sweep and no rider
+    // re-promotion beyond the restore of the ORIGINAL promotion.
+    const ev = new Event("transitionend");
+    Object.defineProperty(ev, "propertyName", { value: "height" });
+    h.frame.dispatchEvent(ev);
+    expect(h.frame.hasAttribute("data-hk-morphing")).toBe(false);
+    expect(h.frame.style.clipPath).toBe("");
+    expect(h.frame.style.height).toBe("483px");
+    // The resident promotions are restored to their armed values (the frame
+    // is at rest), not left demoted and not re-swept.
+    expect(h.frame.style.willChange).toBe("clip-path");
+    expect(rider.style.willChange).toBe("transform");
+
+    // Nothing is left pending: a later observer tick finds the pin already
+    // settled and stays quiet (no delayed conceal).
+    FakeResizeObserver.instances[0]!.callback();
+    await settle();
+    expect(h.frame.style.clipPath).toBe("");
+    expect(h.frame.style.height).toBe("483px");
+    h.stop();
+  });
 });

package/src/composables/useSizeMorph.ts

@@ -625,12 +625,23 @@ export function useSizeMorph(
 
   function remeasure(interrupt = true): void {
     if (!armed) return;
-    if (!interrupt && revealEl !== null) {
+    if (!interrupt && (revealEl !== null || morphDemoted)) {
       // A background measurement must never tear down a live sweep: doing so
       // republished the sweep's own teardown as its LANDING, so a consumer
       // parking geometry for that fold released it ~2ms in and the sheet
       // undid and replayed the fold (real-engine finding). The change is
       // measured as soon as the sweep lands instead.
+      // The same holds while a heightMorph is in flight (morphDemoted): a
+      // stepflow's morph targets the natural height measured the instant the
+      // slide settled, which can sit a few px off the frame's settled rest
+      // height (the chrome-allowance transient, the long-standing +20px
+      // drift). If the observer's settle-debounced remeasure runs mid-morph
+      // it reads that residual as a fresh shrink and replays a CLIP CONCEAL
+      // — re-promoting the riders and sweeping a moving edge for 300ms,
+      // which is exactly the shrink-time flash the phone kept reporting
+      // (round-21 rig: the conceal fired ~152ms into the morph, clobbering
+      // the running height transition before transitionend). Defer it; the
+      // morph's own restore absorbs the drift silently instead.
       pendingMeasure = true;
       return;
     }
@@ -1011,6 +1022,32 @@ export function useSizeMorph(
       morphSavedRiderWills = [];
       morphSavedFrameWill = "";
       morphDemoted = false;
+      // Absorb the settle transient silently. The morph targeted the natural
+      // height measured the instant the slide settled; that figure can sit a
+      // few px off the frame's settled rest height (the chrome-allowance
+      // transient — the long-standing +20px drift). The observer's
+      // settle-debounced remeasure was deferred for the morph's duration
+      // (see the morphDemoted gate in remeasure); if it ran now against the
+      // stale pin it would read the residual as a fresh shrink and replay a
+      // CLIP CONCEAL (re-promoting riders, sweeping a moving edge) — the
+      // shrink-time flash. Re-measure at rest and snap the pin to the
+      // settled height in one transition-disabled task instead: the few-px
+      // correction lands in the same frame the animation ends, so it is
+      // imperceptible, and the deferred remeasure finds nothing to sweep.
+      if (pendingMeasure) {
+        pendingMeasure = false;
+        const inlineT = f.style.transition;
+        f.style.transition = "none";
+        f.style.height = "";
+        const settled = Math.round(f.offsetHeight);
+        if (settled > 0) {
+          f.style.height = `${settled}px`;
+          pinned = settled;
+        } else if (pinned > 0) {
+          f.style.height = `${pinned}px`;
+        }
+        f.style.transition = inlineT;
+      }
     };
     const onEnd = (ev: TransitionEvent): void => {
       if (ev.target === f && ev.propertyName === "height") {