@celestia-island/hikari 0.55.307 → 0.55.309

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celestia-island/hikari",
-  "version": "0.55.307",
+  "version": "0.55.309",
   "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.tsx

@@ -332,7 +332,14 @@ 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.
-        if (bodyRef.value) out.push({ el: bodyRef.value });
+        // 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 && rideStateClass() === null) out.push({ el: bodyRef.value });
         return out;
       },
       // Republish the morph's real sweep span and its landing on the body
@@ -1126,6 +1133,7 @@ export default defineComponent({
             <div
                   ref={contentRef}
                   class={["hk-modal-content", "hk-ride", rideStateClass(), props.contentClass, ...machine.classesFor("hk-modal-content")]}
+                  data-hk-ride-ready={ride.hasCache() ? "" : undefined}
                   role="dialog"
                   aria-modal="true"
                   aria-label={resolvedSurfaceName.value}
@@ -1133,6 +1141,8 @@ export default defineComponent({
                   style={{
                     maxWidth: resolvedWidth.value,
                     zIndex: contentZ.value,
+                    ...ride.styleVars(),
+
                   }}
                   onClick={onContentClick}
                   tabindex={-1}

package/src/components/HkRangeRibbon.test.tsx

@@ -862,6 +862,35 @@ describe("HkRangeRibbon reset", () => {
     expect(second.defaultPrevented).toBe(true);
   });
 
+  it("treats a full-domain window as nothing to reset (raw-records rest state)", async () => {
+    // A minimal-style host rests at the controlled FULL selection [0, 1]:
+    // the grips paint, but there is no narrower selection to come back to.
+    // Escape there must reach the host (the dialog closes), not "reset" the
+    // bar it already shows — before 2026-11-07 every press swallowed the key.
+    const host = mountHost([0, 1]);
+    const strip = host.root.querySelector<HTMLElement>(".hk-range-ribbon-strip")!;
+    const event = keydown(strip, "Escape");
+    await nextTick();
+    expect(host.windowChange, "full selection: nothing resets").not.toHaveBeenCalled();
+    expect(event.defaultPrevented, "a host dialog must still see Escape").toBe(false);
+
+    // The reset BUTTON agrees with Escape: nothing to reset at [0, 1].
+    expect(host.root.querySelector(".hk-range-ribbon-reset")).toBeNull();
+    // The grips stay (they are the selection itself, not a reset affordance).
+    expect(host.root.querySelector(".hk-range-ribbon-handle")).not.toBeNull();
+
+    // A real sub-domain still resets — and the chip is back for it.
+    await host.setWindow([0.3, 0.7]);
+    expect(host.root.querySelector(".hk-range-ribbon-reset")).not.toBeNull();
+    const second = keydown(host.root.querySelector<HTMLElement>(".hk-range-ribbon-strip")!, "Escape");
+    await nextTick();
+    expect(host.windowChange).toHaveBeenLastCalledWith(null);
+    expect(second.defaultPrevented).toBe(true);
+    // Back at the full selection the chip is gone again.
+    await host.setWindow([0, 1]);
+    expect(host.root.querySelector(".hk-range-ribbon-reset")).toBeNull();
+  });
+
   it("cancels an in-flight brush with Escape and consumes the key", async () => {
     const host = mountHost(null);
     const { strip, x } = stubStrip(host.root);
@@ -1496,10 +1525,13 @@ describe("HkRangeRibbon stylesheet contract", () => {
   });
 
   // Wave (2026-11-06 raw-records five): MINIMAL MODE - the bare dual-handle
-  // bar. Contract: data-minimal on the root, strip present + windowed at
-  // the full domain, ZERO lane chrome (no lanes block, no lane rows, no
-  // overview minimap, no gutter probe), and the standard mode keeps its
-  // lane chrome + alignment probe.
+  // bar. Contract: data-minimal on the root, strip present, ZERO lane chrome
+  // (no lanes block, no lane rows, no overview minimap, no gutter probe),
+  // and the standard mode keeps its lane chrome + alignment probe. The
+  // uncontrolled default window is NULL here — the grips need a controlled
+  // non-null window (the chest raw-records adapter feeds [0, 1] for its
+  // "default = everything selected" reading); the aria readings below come
+  // from the strip's null-window fallbacks, not from a real window.
   it("minimal mode renders the bare dual-handle bar (no lane chrome)", () => {
     const root = mountRibbon({ minimal: true });
     expect(root.getAttribute("data-minimal")).toBe("true");
@@ -1507,8 +1539,9 @@ describe("HkRangeRibbon stylesheet contract", () => {
     expect(stripEl).not.toBeNull();
     // The strip carries the slider a11y (role/tabindex/label/valuenow).
     expect(stripEl.getAttribute("aria-label")).toBe("Observation range");
-    // Uncontrolled default window = the FULL domain: valuenow sits at 0
-    // (domain start) and the valuetext reads the whole range.
+    // No window ⇒ the strip's aria falls back to the full range ("0" /
+    // "0% – 100%"): a truthful reading for an unfiltered bar, even though
+    // no grips paint without a controlled window.
     expect(stripEl.getAttribute("aria-valuenow")).toBe("0");
     expect(stripEl.getAttribute("aria-valuetext")).toContain("0%");
     // The lanes BLOCK is skipped entirely (no lane rows at all).
@@ -1522,7 +1555,6 @@ describe("HkRangeRibbon stylesheet contract", () => {
     //  static scss assertion at the end of this file — happy-dom cannot
     //  resolve the nested attribute selector.)
     expect(root.querySelector(".hk-range-ribbon-overview-segment")).toBeNull();
-    // Uncontrolled default window = the FULL domain (edge to edge).
     // Standard consumers keep the lane chrome + the alignment probe.
     const std = mountRibbon({});
     expect(std.querySelector(".hk-range-ribbon-lane")).not.toBeNull();

package/src/components/HkRangeRibbon.tsx

@@ -264,9 +264,12 @@ export default defineComponent({
      *  range bar. No lane rows, no overview minimap, no label gutter; the
      *  strip spans the full width and its track uses muted-based tokens
      *  (the surface-based track read whitish inside dark phone modals).
-     *  The uncontrolled default window is already the FULL domain, so a
-     *  minimal bar starts pinned edge to edge. `segments` / `selectedId`
-     *  are IGNORED in this mode (no segment DOM to select from). */
+     *  The grips paint only for a NON-null window, so an uncontrolled
+     *  minimal bar starts as a bare track; a host that wants the "default =
+     *  everything selected" reading feeds the controlled window `[0, 1]`
+     *  (the chest raw-records adapter does exactly that).
+     *  `segments` / `selectedId` are IGNORED in this mode (no segment DOM to
+     *  select from). */
     minimal: { type: Boolean, default: false },
   },
   emits: {
@@ -350,9 +353,21 @@ export default defineComponent({
       return true;
     }
 
-    /** Returns true when a window actually existed (and was cleared), so the
-     *  caller can leave Escape alone when the host needs it. */
+    /** A window that covers the whole domain IS the unfiltered state — there
+     *  is nothing to reset back to (2026-11-07, the raw-records consumer: a
+     *  minimal bar paints its grips for a non-null window, so its rest state
+     *  is the FULL selection `[0, 1]`; without this check Escape "reset" it
+     *  every press, swallowed the key, and the hosting dialog could never
+     *  close while the bar held focus). */
+    function isFullDomain(win: WindowRange | null): boolean {
+      return win !== null && win[0] <= WINDOW_EPSILON && win[1] >= 1 - WINDOW_EPSILON;
+    }
+
+    /** Returns true when a window actually existed AND was narrower than the
+     *  full domain (and was cleared), so the caller can leave Escape alone
+     *  when the host needs it — a full-domain window has nothing to reset. */
     function resetWindow(): boolean {
+      if (isFullDomain(activeWindow.value)) return false;
       if (!commitIfChanged(null)) return false;
       // A reset that interrupts a drag (Escape mid-brush) must drop the
       // gesture too, or the next pointermove re-brushes from the stale
@@ -818,7 +833,10 @@ export default defineComponent({
                       focus; this sheet only pins the seat (position) and a
                       surface backing via its override vars. The glyph slots
                       as a lucide component (the house-normal integration:
-                      every in-tree HkIconButton slots its glyph). */}
+                      every in-tree HkIconButton slots its glyph). A
+                      full-domain window has nothing to reset, so the chip
+                      only renders for a REAL sub-domain selection. */}
+                  {win && !isFullDomain(win) && (
                   <HIconButton
                     class="hk-range-ribbon-reset"
                     size={24}
@@ -829,6 +847,7 @@ export default defineComponent({
                   >
                     {{ icon: () => <RotateCcw aria-hidden="true" /> }}
                   </HIconButton>
+                  )}
                 </>
               )}
             </div>

package/src/components/HkRideBox.scss

@@ -76,6 +76,11 @@
   height: var(--hk-ride-content, auto);
 }
 
+.hk-ride[data-hk-ride-ready].hk-ride--from > .hk-ride-chrome-start,
+.hk-ride[data-hk-ride-ready].hk-ride--to > .hk-ride-chrome-start {
+  flex-shrink: 0;
+}
+
 .hk-ride[data-hk-ride-ready].hk-ride--from > .hk-ride-chrome-end,
 .hk-ride[data-hk-ride-ready].hk-ride--to > .hk-ride-chrome-end {
   position: absolute;

package/src/composables/useHeightRide.ts

@@ -70,6 +70,14 @@ export interface HeightRide {
    *  ride needs); calling it mid-ride re-measures the live, compressed
    *  box and is therefore a no-op unless `force` is passed. */
   refresh(force?: boolean): boolean;
+  /** Inline style vars for the CURRENT cache, or null when nothing has
+   *  been measured yet. Consumers bind this in their render so the very
+   *  first painted frame of a remount already carries the ride (a post-
+   *  mount publish is one paint too late: the enter-from frame would show
+   *  a full-height frame with unscaled content — read as "clipping"). */
+  styleVars(): Record<string, string> | null;
+  /** True when a measured split exists (drives the ready attribute). */
+  hasCache(): boolean;
   /** Re-apply the LAST measured split without touching the DOM boxes.
    *  A surface that unmounts its frame on close loses the inline variables
    *  with it; republishing on the next mount is what makes the very first
@@ -138,15 +146,12 @@ export function useHeightRide(
       if (child === c || !(child instanceof HTMLElement)) continue;
       chromeNatural += child.offsetHeight;
     }
-    // At rest the frame is at (or pinned to) its natural height, so the
-    // content region's natural height is the honest difference there; mid
-    // flight only the content's own box is trustworthy (the frame is short
-    // by design). Both branches are frame-height independent when it
-    // matters — a compressed frame never feeds the next ride.
-    const contentNatural = isInFlight(f)
-      ? c.offsetHeight
-      : Math.max(0, f.offsetHeight - chromeNatural);
-    const measured = contentNatural > 0 ? contentNatural : c.offsetHeight;
+    // The content region's own layout box is the ONLY honest source. With
+    // no ride class the body is flex-natural; while a ride class is present
+    // the box is locked to the published var (stable, no new information —
+    // and the frame's height is the ride's own output, so deriving the
+    // content from it would feed every early error forward forever).
+    const measured = c.offsetHeight;
     if (measured <= 0) return false;
     contentH = measured;
     chrome = chromeNatural;
@@ -172,8 +177,19 @@ export function useHeightRide(
     return true;
   };
 
+  const styleVars = (): Record<string, string> | null =>
+    contentH <= 0
+      ? null
+      : {
+          "--hk-ride-chrome": `${chrome}px`,
+          "--hk-ride-content": `${contentH}px`,
+          "--hk-ride-factor": String(factorOf()),
+        };
+
   return {
     refresh,
+    styleVars,
+    hasCache: () => contentH > 0,
     publish,
     chromeHeight: () => chrome,
     contentHeight: () => contentH,