@celestia-island/hikari 0.55.310 → 0.55.311

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celestia-island/hikari",
-  "version": "0.55.310",
+  "version": "0.55.311",
   "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.open-close-scale.test.ts

@@ -11,7 +11,8 @@
  * frame maps its surface phases onto `hk-ride--from` / `hk-ride--to`):
  *
  *   frame height  : chrome + content × 0.9   ⇄   chrome + content
- *   content region: scaleY(0.9)              ⇄   scaleY(1)   (origin top)
+ *   frame        : translateY(10px) scale(0.97) ⇄ translateY(0) scale(1)
+ *   content/body : never transformed (the whole window zooms)
  *
  * The retired grammars, oldest first: the 2026-11-04 whole-frame
  * `scale(1, 0.9)`, the 2026-11-05 body-only uniform `scale(0.9)`, the
@@ -323,8 +324,8 @@ const CENTERING =
 /** Frame ride states: the centering translate is a PERMANENT prefix and
  *  only the appended scaleY changes (2026-11-06: the window's height rides
  *  the open/close about its center). */
-const FRAME_FROM = `${CENTERING} scaleY(0.9)`;
-const FRAME_TO = `${CENTERING} scaleY(1)`;
+const FRAME_FROM = `${CENTERING} translateY(10px) scale(0.97)`;
+const FRAME_TO = `${CENTERING} translateY(0) scale(1)`;
 
 /** Exact compiled transition values (winner()-normalized) — pinned whole,
  *  not by prefix: an embedded fourth time value (delay) or a smuggled extra
@@ -333,10 +334,10 @@ const FRAME_TO = `${CENTERING} scaleY(1)`;
  *  R2 finding 2026-11-06 (S1): prefix `toContain` let both survive. */
 const ENTER_TRANSITION =
   "opacity var(--hk-modal-duration, 0.42s) var(--hk-modal-ease-out, cubic-bezier(0.33, 1, 0.68, 1)), " +
-  "height var(--hk-modal-duration, 0.42s) var(--hk-modal-ease-out, cubic-bezier(0.33, 1, 0.68, 1))";
+  "transform var(--hk-modal-duration, 0.42s) var(--hk-modal-ease-out, cubic-bezier(0.33, 1, 0.68, 1))";
 const LEAVE_TRANSITION =
   "opacity var(--hk-modal-duration, 0.32s) var(--hk-modal-ease-in, cubic-bezier(0.45, 0, 0.55, 1)), " +
-  "height var(--hk-modal-duration, 0.32s) var(--hk-modal-ease-in, cubic-bezier(0.45, 0, 0.55, 1))";
+  "transform var(--hk-modal-duration, 0.32s) var(--hk-modal-ease-in, cubic-bezier(0.45, 0, 0.55, 1))";
 /** The ride's own geometry lives in the shared container sheet; the modal
  *  frame maps its phases onto these two ends. */
 const RIDE_SHEET = (() => {
@@ -355,17 +356,24 @@ describe("HkModal desktop open/close contract (compiled cascade, user direction
     expect(selectors.some((s) => s.includes("hk-modal-content-enter-from"))).toBe(true);
   });
 
-  it("keeps the frame's transform at the plain centering translate in every state", () => {
-    // The ride is layout height, not a frame transform — that is the whole
-    // point (a frame scale squashed the chrome). So the transform must be
-    // the SAME `translate(...)` in rest and at both ride ends, and adding a
-    // scale to it in any state is the regression this pins.
+  it("rides the whole window on the centering translate plus a zoom pair", () => {
+    // B3 (user direction 2026-11-07, fifth revision): the frame's transform
+    // is the PERMANENT centering translate with a translateY+scale appended
+    // — a compositor-only motion. Rest keeps the bare translate; the two
+    // ride ends are the contracted zoom pair, byte-identical across the
+    // draggable variant. Anything else (a bare scale, a lost shift token,
+    // a different function order) is the regression this pins.
     for (const state of [...RIDE, { name: "rest", classes: [] as string[] }]) {
+      const compressed = state.classes.some((c) =>
+        c.includes("enter-from") || c.includes("leave-to"));
+      const expected = state.classes.length === 0
+        ? CENTERING
+        : compressed ? FRAME_FROM : FRAME_TO;
       for (const [label, frame] of [
         ["", frameWith(...state.classes)],
         ["draggable ", draggableFrameWith(...state.classes)],
       ] as const) {
-        expect(winner(frame, "transform", DESKTOP), `${label}${state.name}`).toBe(CENTERING);
+        expect(winner(frame, "transform", DESKTOP), `${label}${state.name}`).toBe(expected);
         for (const prop of ["scale", "zoom", "translate", "rotate", "transform-origin"]) {
           expect(winner(frame, prop, DESKTOP), `${label}${state.name} ${prop}`).toBeUndefined();
         }
@@ -416,14 +424,14 @@ describe("HkModal desktop open/close contract (compiled cascade, user direction
       "will-change",
       DESKTOP,
     );
-    expect(enterWill).toBe("opacity");
+    expect(enterWill).toBe("opacity, transform");
     // The close direction promotes the same pair of layers.
     const leaveWill = winner(
       frameWith("hk-modal-content-leave-to", "hk-modal-content-leave-active"),
       "will-change",
       DESKTOP,
     );
-    expect(leaveWill).toBe("opacity");
+    expect(leaveWill).toBe("opacity, transform");
   });
 
   it("rides the HEIGHT through the shared container contract, chrome untouched", () => {
@@ -626,17 +634,6 @@ describe("HkModal desktop open/close contract (compiled cascade, user direction
       "transition",
       "will-change",
       "opacity",
-      // The from-pair carries the ride's height end, and the -active pair
-      // locks the content region out of the flex shrink for the flight
-      // (the 0.81-compounding guard, 2026-11-07 R3 finding).
-      "height",
-      "flex",
-      // …and the -active pair pins the footer band to the frame's bottom
-      // edge for the flight (it would otherwise be pushed out by the
-      // content region's locked natural box).
-      "position",
-      "inset-inline",
-      "bottom",
     ]);
     // Chrome ride states now also carry `transform` (the 2026-11-06 frame
     // height ride) — but nothing else beyond opacity/transition/will-change.
@@ -718,12 +715,7 @@ describe("HkModal desktop open/close contract (compiled cascade, user direction
       const bodyTransform = winner(body, "transform", DESKTOP) ?? "";
       // The contracted body grammar: nothing but the vertical compression
       // at the ride's two ends (and no transform at rest).
-      const expectCompressed = state.classes.some((c) =>
-        c.includes("enter-from") || c.includes("leave-to"));
-      const expected = expectCompressed
-        ? "scaleY(var(--hk-ride-factor, 0.9))"
-        : "scaleY(1)";
-      expect(bodyTransform, `body ${state.name}`).toBe(expected);
+      expect(bodyTransform, `body ${state.name}`).toBe("");
       expect(winner(body, "scale", DESKTOP), `body ${state.name}`).toBeUndefined();
       expect(winner(body, "translate", DESKTOP), `body ${state.name}`).toBeUndefined();
       expect(winner(body, "zoom", DESKTOP), `body ${state.name}`).toBeUndefined();
@@ -732,7 +724,10 @@ describe("HkModal desktop open/close contract (compiled cascade, user direction
       // the only `scaleY` in the choreography lives on the content region's
       // shared contract (pinned by the ride test above).
       const frameTransform = winner(frame, "transform", DESKTOP) ?? "";
-      expect(frameTransform, `frame ${state.name}`).toBe(CENTERING);
+      const compressed = state.classes.some((c) =>
+        c.includes("enter-from") || c.includes("leave-to"));
+      const frameExpected = compressed ? FRAME_FROM : FRAME_TO;
+      expect(frameTransform, `frame ${state.name}`).toBe(frameExpected);
       expect(frameTransform, `frame ${state.name}`).not.toMatch(FRAME_ESCAPES);
       expect(winner(frame, "scale", DESKTOP), `frame ${state.name}`).toBeUndefined();
       expect(winner(frame, "zoom", DESKTOP), `frame ${state.name}`).toBeUndefined();

package/src/components/HkModal.scss

@@ -57,11 +57,11 @@
   z-index: 1;
   top: 50%;
   left: 50%;
-  // The centering translate is the frame's WHOLE transform, in every state
-  // (rest, enter-from/to, leave-from/to). The open/close ride is carried by
-  // the height instead (see the choreography block below), so the frame can
-  // never re-seat mid-flight, dragged windows keep their shift, and the
-  // chrome is never scaled.
+  // The centering translate is the frame's PERMANENT transform prefix:
+  // every state (rest, enter-from/to, leave-from/to) carries this exact
+  // translate, and the open/close choreography only ever APPENDS a
+  // translateY + scale to it (see the desktop block) — so the ride can
+  // never re-seat the frame and dragged windows keep their shift.
   transform: translate(
         calc(-50% + var(--hk-modal-shift-x, 0px)),
         calc(-50% + var(--hk-modal-shift-y, 0px))
@@ -137,126 +137,60 @@
 // ------
 
 @media (min-width: 768px) {
-  // RESIDENT legs — the ride's continuity never depends on the transition
-  // classes' lifetime. The surface machine's deadline is advisory: it can
-  // flip the phase (and drop the classes) before the CSS lands. With the
-  // legs resident, that class drop only changes the TARGET (calc -> auto,
-  // scale -> none) and the browser finishes the motion on these legs
-  // instead of snapping (2026-11-07 user report: the open "replayed" — a
-  // partial ride, a snap, then a second animation). The height/max-height/
-  // clip-path legs stay at the base tokens for the size morph (its own
-  // heightMorph overrides the duration inline when it runs).
-  .hk-modal-content {
-    // Let the height leg interpolate to/from `auto` (Chromium 129+; older
-    // engines just snap that one handoff): when the transition classes come
-    // off mid-ride the calc end becomes the frame's own `auto` layout, and
-    // without this the motion would jump instead of finishing.
-    interpolate-size: allow-keywords;
-    transition:
-      opacity var(--hk-modal-duration, 0.42s)
-        var(--hk-modal-ease-out, cubic-bezier(0.33, 1, 0.68, 1)),
-      height var(--hk-modal-duration, 0.42s)
-        var(--hk-modal-ease-out, cubic-bezier(0.33, 1, 0.68, 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));
-  }
-
-  // The content's compression leg is resident for the same reason — and it
-  // is what makes the ENTER start at exactly scaleY(0.9): a freshly
-  // inserted element's first style never transitions, so the from-pair
-  // paints at 0.9 and only ever animates from there.
-  .hk-modal-body {
-    transition: transform var(--hk-modal-duration, 0.42s)
-      var(--hk-modal-ease-out, cubic-bezier(0.33, 1, 0.68, 1));
-  }
-
-  // Open: the window's height rides while the chrome keeps its size.
+  // Whole-window zoom + gentle rise + fade (user direction 2026-11-07,
+  // fifth revision, chosen from a side-by-side comparison page):
+  //
+  //   transform: translateY(10px) scale(0.97)  ->  translateY(0) scale(1)
+  //   opacity  : 0 -> 1
+  //
+  // A COMPOSITOR animation end to end: no layout property moves, so nothing
+  // reflows per frame and the backdrop-filtered fixed layer never re-rasters
+  // — the previous height-ride choreography (0.55.307–0.55.310) animated the
+  // frame's layout height and read as jank on content-heavy windows. The 3%
+  // scale is imperceptible as glyph distortion while still giving the window
+  // a sense of arriving; the 10px rise adds direction. The centering
+  // translate stays the frame's PERMANENT transform prefix (byte-identical
+  // in every state, `--hk-modal-shift-*` included) so the ride can never
+  // re-seat the frame and dragged windows keep their shift.
   .hk-modal-content-enter-active {
     transition:
       opacity var(--hk-modal-duration, 0.42s)
         var(--hk-modal-ease-out, cubic-bezier(0.33, 1, 0.68, 1)),
-      height var(--hk-modal-duration, 0.42s)
+      transform var(--hk-modal-duration, 0.42s)
         var(--hk-modal-ease-out, cubic-bezier(0.33, 1, 0.68, 1));
-    will-change: opacity;
+    will-change: opacity, transform;
   }
 
-  // Close: the reveal's TRUE reverse — same ride, the window settles back
-  // toward 90% height, width untouched in both directions.
+  // Close: the true reverse — the window settles back to 0.97 and dips
+  // 10px while it fades. Width, height and chrome never move in either
+  // direction.
   .hk-modal-content-leave-active {
     transition:
       opacity var(--hk-modal-duration, 0.32s)
         var(--hk-modal-ease-in, cubic-bezier(0.45, 0, 0.55, 1)),
-      height var(--hk-modal-duration, 0.32s)
+      transform var(--hk-modal-duration, 0.32s)
         var(--hk-modal-ease-in, cubic-bezier(0.45, 0, 0.55, 1));
-    will-change: opacity;
+    will-change: opacity, transform;
   }
 
-  // The ride's two ends. The from-pair ships with the FIRST paint (a
-  // freshly inserted element does not transition into its initial style),
-  // so the compressed height and the 0.9 content scale are both real at
-  // frame one — the phase-mapped classes that shipped one tick late are
-  // exactly what made the open look like clipping (2026-11-07 reports).
-  // `!important` outranks the size morph's inline pin for the flight.
-  .hk-modal-content[data-hk-ride-ready].hk-modal-content-enter-from,
-  .hk-modal-content[data-hk-ride-ready].hk-modal-content-leave-to {
+  .hk-modal-content-enter-from,
+  .hk-modal-content-leave-to {
     opacity: 0;
-    height: calc(
-      var(--hk-ride-chrome, 0px) + var(--hk-ride-content, 0px) * var(--hk-ride-factor, 0.9)
-    ) !important;
+    transform: translate(
+          calc(-50% + var(--hk-modal-shift-x, 0px)),
+          calc(-50% + var(--hk-modal-shift-y, 0px))
+        )
+        translateY(10px) scale(0.97);
   }
 
-  // The natural end is an EXPLICIT calc too: the frame's base height is
-  // `auto`, and a transition cannot interpolate px -> auto. Without this
-  // leg the -active body lock made `auto` resolve to (almost) the
-  // compressed height, so the frame never grew while the content's scale
-  // unfolded underneath it — the "clipped open" the user reported. When the
-  // classes come off at rest, the morph's pin (the same px) catches the
-  // handoff with no visible change.
   .hk-modal-content-enter-to,
   .hk-modal-content-leave-from {
     opacity: 1;
-    height: calc(var(--hk-ride-chrome, 0px) + var(--hk-ride-content, 0px));
-  }
-
-  // Only the content region is ever scaled — top origin, so the compressed
-  // paint lands exactly in the shorter slot the frame leaves for it.
-  .hk-modal-content-enter-from > .hk-modal-body,
-  .hk-modal-content-leave-to > .hk-modal-body {
-    transform: scaleY(var(--hk-ride-factor, 0.9));
-    transform-origin: 50% 0;
-  }
-
-  .hk-modal-content-enter-to > .hk-modal-body,
-  .hk-modal-content-leave-from > .hk-modal-body {
-    transform: scaleY(1);
-    transform-origin: 50% 0;
-  }
-
-  // The content region keeps its NATURAL layout height for the whole
-  // flight (or the slot shrink and the scale would compound to 0.81 and
-  // leave a gap above the footer), and the footer pins to the frame's
-  // bottom edge so it stays visible while the content's natural box
-  // overflows underneath it. The -active pair spans the flight window in
-  // both directions.
-  .hk-modal-content-enter-active > .hk-modal-body,
-  .hk-modal-content-leave-active > .hk-modal-body {
-    flex: 0 0 auto;
-    height: var(--hk-ride-content, auto);
-  }
-
-  .hk-modal-content-enter-active > .hk-modal-footer,
-  .hk-modal-content-leave-active > .hk-modal-footer {
-    position: absolute;
-    inset-inline: 0;
-    bottom: 0;
-  }
-
-  // Close-direction compression timing for the content (the frame's height
-  // leg above is 0.32s ease-in; a 0.42s content leg would trail it and open
-  // a gap above the pinned footer).
-  .hk-modal-content-leave-active > .hk-modal-body {
-    transition: transform var(--hk-modal-duration, 0.32s)
-      var(--hk-modal-ease-in, cubic-bezier(0.45, 0, 0.55, 1));
+    transform: translate(
+          calc(-50% + var(--hk-modal-shift-x, 0px)),
+          calc(-50% + var(--hk-modal-shift-y, 0px))
+        )
+        translateY(0) scale(1);
   }
 }
 
@@ -735,7 +669,7 @@
   .hk-modal-content {
     transition: none;
   }
-  // The frame's height ride flattens with it: the ride states fall back to
+  // The zoom choreography flattens with it: the ride states fall back to
   // the bare centering translate (same specificity as the desktop state
   // rules above, later in the sheet, so the flattened state wins by source
   // order — one painted frame at opacity 0 hides the flip).
@@ -746,11 +680,8 @@
       calc(-50% + var(--hk-modal-shift-y, 0px))
     );
   }
-  // The content region carries no transform of its own any more (the ride is
-  // height-only — 2026-11-07). These lines are a belt-and-braces guard only:
-  // at (0,2,0) they would NOT outrank a future ride rule at (0,4,0), so the
-  // family sheet's own reduced-motion block (which repeats the full
-  // selector) is the one that actually flattens the content scale.
+  // The content region carries no transform of its own in this choreography
+  // (the whole window zooms; the body is never scaled). Belt-and-braces.
   .hk-modal-content .hk-modal-body {
     transform: none;
     transition: none;

package/src/components/HkModal.tsx

@@ -18,7 +18,6 @@ import { useSurfaceTransition } from "../composables/useSurfaceTransition";
 import { useSurfaceMachine } from "../composables/useSurfaceMachine";
 import { useSurfaceContentHold } from "../composables/useSurfaceContentHold";
 import { useSizeMorph, type RideEntry } from "../composables/useSizeMorph";
-import { useHeightRide } from "../composables/useHeightRide";
 
 import { STEPFLOW_SWAP_EVENT } from "./HkStepFlow";
 
@@ -332,14 +331,8 @@ export default defineComponent({
         // finding). Riding the block keeps the scrollport's content
         // untransformed; the block's own poke below the frame lands
         // off-screen on a bottom-docked sheet.
-        // While the desktop height ride owns the body's paint (its scaleY
-        // IS the choreography), the morph must not write an inline transform
-        // on the same element: an inline style outranks the ride's class
-        // rule, and the close would stop compressing (2026-11-07 user
-        // report: the window folded "together with the chrome"). The body
-        // ride matters for the ≤767px sheet sweep, where the ride geometry
-        // is disabled — so the two never legitimately overlap.
-        if (bodyRef.value && !desktopRide()) out.push({ el: bodyRef.value });
+        if (bodyRef.value) out.push({ el: bodyRef.value });
+        if (bodyRef.value) out.push({ el: bodyRef.value });
         return out;
       },
       // Republish the morph's real sweep span and its landing on the body
@@ -361,47 +354,11 @@ export default defineComponent({
       },
     });
 
-    // Desktop open/close: the WINDOW's own height rides, the chrome
-    // (title bar, sub-header, footer) keeps its natural size, and only the
-    // content region is visually compressed. The measurement half lives in
-    // the family primitive (useHeightRide); this sheet maps its surface
-    // states onto the ride's two ends (see the choreography block below).
-    const ride = useHeightRide(contentRef, bodyRef, { factor: 0.9 });
-
     /** The window ride's own state, translated from the surface phases:
      *  the open/close endpoints are the compressed end (`--from`) and the
      *  natural end (`--to`). Between and after them no ride class is
      *  present, so the frame keeps its laid-out height (or the morph's
      *  px pin) and the geometry contract never leaks into the rest state. */
-    // The body element mounts with the frame on every open, and the inline
-    // variables die with the previous frame. Republish the split cached from
-    // the last rest measurement FIRST (so the first painted frame is already
-    // correct), then — if this is the very first open — measure as soon as
-    // the element lands (the sheet keeps the frame at `auto` until then, so
-    // that measurement sees honest natural geometry).
-    watch(
-      bodyRef,
-      (el) => {
-        if (!el) return;
-        // ALWAYS measure: the component instance survives a close, so a
-        // cached split may belong to different content (this modal is reused
-        // across tabs/entries). Publishing the cache first made the second
-        // and later opens ride the PREVIOUS geometry, cropping new content
-        // and then snapping when the cache expired (R5 finding).
-        void nextTick(() => ride.refresh());
-      },
-      { flush: "post" },
-    );
-
-    // The ride's geometry lives behind `@media (min-width: 768px)`, so the
-    // phase->class mapping alone cannot tell whether the ride actually owns
-    // the frame (on a phone the classes land but nothing happens). This
-    // predicate gates every "is the ride flying" decision below.
-    const desktopRide = (): boolean =>
-      typeof window !== "undefined" &&
-      window.matchMedia("(min-width: 768px)").matches;
-
-
     let previouslyFocused: HTMLElement | null = null;
     let unmounted = false;
 
@@ -620,10 +577,6 @@ export default defineComponent({
       ],
       onPhase: (from, to, event) => {
         if (to === "openingFrom") {
-          // Measure BEFORE the enter classes land: the ride's `height:
-          // calc()` needs the rest chrome/content split, and a frame that is
-          // already compressed reports the compressed box.
-          ride.refresh();
           // Open-request bookkeeping (was the modelValue watcher's open
           // arm): registration, overlay registry, back-guard, focus
           // capture.
@@ -653,71 +606,13 @@ export default defineComponent({
           void nextTick(() => {
             const p = machine.phase.value;
             if (p !== "openingFrom" && p !== "openingTo") return;
-            // DESKTOP RIDE FLIGHT = MORPH BLACKOUT. While the ride owns the
-            // frame, the morph must not write anything to it: arming installs
-            // a ResizeObserver on the body, and the ride's own class change
-            // (locking the body to its measured height) fires it — the
-            // remeasure then lands `transition: none` mid-flight, which kills
-            // the ride's running height/scaleY transitions and pins the
-            // COMPRESSED used height as if it were natural (2026-11-07 user
-            // report: the open "replays" — ride animates part-way, snaps to
-            // the bad pin, then re-animates to full height). The morph arms at
-            // the open edge instead, where the ride classes are already off
-            // and the pin equals the used height (no visible change). The
-            // phone keeps the enter-edge arm: its sheet choreography rides
-            // the morph's clip sweep, and the ride geometry is gated off.
-            if (!desktopRide()) morph.start();
+            if (p === "openingFrom" || p === "openingTo") morph.start();
           });
         } else if (to === "open") {
           surfTrack.cancel();
-          // Re-measure at the landed rest geometry so the NEXT ride starts
-          // from this box (content may have changed while the surface opened).
-          void nextTick(() => ride.refresh());
           onAfterEnter();
-          // Idempotent re-arm for the fast paths (see openingFrom) — but on
-          // desktop the ride may still be RUNNING when the machine flips to
-          // `open` (its deadline is advisory): arming the morph right now
-          // would land `transition: none` + a px pin on a frame whose height
-          // is mid-transition, snapping it to the end value (2026-11-07
-          // user report: the window "jumps" the last third of its growth).
-          // Wait for the height leg to actually land (watchdog: the budget
-          // plus slack), then arm — the pin then equals the used height and
-          // the handoff is invisible. The phone has no ride; arm at once.
-          if (desktopRide()) {
-            const f = contentRef.value;
-            const armNow = (): void => {
-              if (machine.phase.value !== "open" || unmounted) return;
-              morph.start();
-            };
-            // No live CSS duration (test DOMs, reduced motion, the global
-            // animation switch): nothing is animating, arm at once — the
-            // same zero-duration semantics the surface machine uses.
-            const rawDuration = f ? getComputedStyle(f).transitionDuration : "";
-            const durMs = rawDuration
-              .split(",")
-              .map((part) => parseFloat(part))
-              .filter((v) => Number.isFinite(v))
-              .reduce((a, b) => Math.max(a, b), 0);
-            if (!f || durMs === 0) {
-              armNow();
-            } else {
-              let done = false;
-              const finish = (): void => {
-                if (done) return;
-                done = true;
-                f.removeEventListener("transitionend", onHeightEnd);
-                clearTimeout(guard);
-                armNow();
-              };
-              const onHeightEnd = (e: TransitionEvent): void => {
-                if (e.target === f && e.propertyName === "height") finish();
-              };
-              const guard = setTimeout(finish, 600);
-              f.addEventListener("transitionend", onHeightEnd);
-            }
-          } else {
-            morph.start();
-          }
+          // Idempotent re-arm for the fast paths (see openingFrom).
+          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
@@ -726,9 +621,6 @@ export default defineComponent({
             if (machine.phase.value === "open") morph.remeasure();
           });
         } else if (to === "closingFrom") {
-          // Same rule on the way out: the frame is at its open (natural)
-          // height right now, so this is the last honest measurement.
-          ride.refresh();
           // Close-request bookkeeping (was the watcher's close arm): the
           // registries forget the surface at request time; the finalize
           // edge below completes the teardown at leave end.
@@ -1185,7 +1077,6 @@ export default defineComponent({
             <div
                   ref={contentRef}
                   class={["hk-modal-content", props.contentClass, ...machine.classesFor("hk-modal-content")]}
-                  data-hk-ride-ready={ride.hasCache() ? "" : undefined}
                   role="dialog"
                   aria-modal="true"
                   aria-label={resolvedSurfaceName.value}
@@ -1193,7 +1084,6 @@ export default defineComponent({
                   style={{
                     maxWidth: resolvedWidth.value,
                     zIndex: contentZ.value,
-                    ...ride.styleVars(),
 
                   }}
                   onClick={onContentClick}