@fusion.dev/helix 0.58.1 → 0.59.0

package/dist/aura/root/aura-root.d.ts

@@ -193,9 +193,7 @@ export declare class HelixAura extends HelixElement {
     private release;
     /** What every context is asked for, here rather than at two call sites. */
     private static readonly CONTEXT;
-    private frame;
     private elapsed;
-    private last;
     private width;
     private height;
     /**
@@ -233,13 +231,16 @@ export declare class HelixAura extends HelixElement {
      */
     private readonly target;
     private readonly eased;
-    private motion;
-    private visible;
     /**
-     * What the intersection observer last said, kept because it says so only on
-     * a change: every other path to `play` has to ask it.
+     * Whether anybody is looking, and the loop that draws for them.
+     *
+     * **Four reasons to refuse a frame that the gate cannot know**: a context it
+     * was never given, one the browser has taken, a drawing buffer no measurement
+     * has sized, and an opening frame still owed. The first two draw nothing at
+     * all and the last two draw at the wrong scale, which `measure` and `opened`
+     * each have their own note about.
      */
-    private onScreen;
+    private readonly gate;
     /**
      * The element's box, cached.
      *
@@ -251,8 +252,6 @@ export declare class HelixAura extends HelixElement {
      * from the handler that reads it.
      */
     private box;
-    /** Watches the element's own size, so no frame has to ask for it. */
-    private sized;
     /**
      * Whether the field has drawn its opening frame yet.
      *
@@ -397,9 +396,9 @@ export declare class HelixAura extends HelixElement {
      *
      * **Taken on a GPU reset, and past the cap** of about sixteen, where the
      * browser drops the oldest context for the newest while its aura is still on
-     * screen. `tick` books its own next frame, so the loop went on at 30 frames a
-     * second against a context that draws nothing, and nothing made the program
-     * again once the context came back: the aura never recovered.
+     * screen. Unstopped, the loop runs at 30 frames a second against a context
+     * that draws nothing, and nothing makes the program again once the context
+     * comes back: the aura never recovers.
      *
      * **The canvas is hidden until then, because a lost one is not reliably
      * transparent.** Measured 15 Sep 2026: headless Chromium painted a plain
@@ -436,15 +435,27 @@ export declare class HelixAura extends HelixElement {
      * Re-reads the box and resizes the drawing buffer to match.
      *
      * **Called from the observer, never from the frame.** `clientWidth` is a
-     * layout read, and doing it in `tick` meant a forced synchronous layout on
+     * layout read, and doing it per frame meant a forced synchronous layout on
      * every single frame to learn a number that changes when the box changes and
-     * at no other time. A `ResizeObserver` is told when that is.
+     * at no other time. The gate's `ResizeObserver` is told when that is.
      *
      * Returns whether the drawing buffer was resized, which is the same question
      * as whether it was cleared, and so whether the caller owes it a frame.
      */
     private measure;
     private paint;
+    /**
+     * The box changed, which is the one moment the buffer is re-measured.
+     *
+     * **A resize repaints unconditionally rather than asking.** `measure` clears
+     * the drawing buffer whenever it resizes it, because assigning `canvas.width`
+     * is a reset and not a hint. `paintOnce` declines while the loop holds a
+     * frame, which is right for a property change the loop is about to draw
+     * anyway and wrong here: the canvas is already transparent by the time it
+     * declines, so the fallback gradient underneath showed through until the next
+     * frame landed. One frame, on every reflow that changed the box.
+     */
+    private resized;
     /**
      * The opening frame, one animation frame after the box last changed.
      *
@@ -456,12 +467,13 @@ export declare class HelixAura extends HelixElement {
     /** One frame, now, for a change that has to show while the loop is stopped. */
     private paintOnce;
     /**
-     * The shortest gap between two painted frames, for a field nobody points at.
+     * The shortest gap between two painted frames, in seconds, for a field nobody
+     * points at.
      *
      * **A drifting field does not need the display's rate and a pointer does.**
-     * `tick` advances on `(now - this.last) / 1000`, so motion is wall-clock: at
-     * half the frames the field moves the same distance in the same time, sampled
-     * more coarsely. `delta` is already clamped at 0.05, which is a floor of 20
+     * The field advances on the gate's own step, so motion is wall-clock: at half
+     * the frames it moves the same distance in the same time, sampled more
+     * coarsely. That step is clamped at `MAX_FRAME_STEP`, which is a floor of 20
      * frames a second, and 30 sits inside that with room. A cap at 15 would land
      * on the clamp and the field would genuinely drag, which is the failure that
      * would be misdiagnosed as choppiness.
@@ -480,23 +492,16 @@ export declare class HelixAura extends HelixElement {
      * callback. Capping the two that nobody points at is most of that back.
      */
     private static readonly CAPPED;
-    private readonly tick;
     /**
-     * Starts the loop, where it is wanted and can be ended.
-     *
-     * **Never while detached.** `tick` books its own next frame, so the only
-     * thing that ends the loop is `stop`, and a disconnection is the last time
-     * `stop` is called. Everything that plays is canceled or disconnected there,
-     * and this holds for whatever callback was already on its way.
+     * What the skipped frames were worth, in seconds, spent on the next one drawn.
      *
-     * **Nor off screen, whoever asks.** The observer is the one caller that
-     * knows, and a tab coming back, a resize and a restored context all play
-     * too. An aura 2600 pixels below the fold booked no frame at rest and one on
-     * every frame after its tab came back, until it had been scrolled in and out
-     * again. Nor on a lost context, which draws nothing.
+     * Dropping it instead would make the field move at a fraction of wall-clock
+     * speed, which is the thing the cap is written not to do: a capped frame is
+     * the same motion sampled more coarsely and not less motion. Held rather than
+     * measured from a stamp, because the gate owns the clock.
      */
-    private play;
-    private stop;
+    private held;
+    private advance;
     /**
      * The angle actually drawn, which is `terminus` resolved against the box.
      *
@@ -535,23 +540,6 @@ export declare class HelixAura extends HelixElement {
      */
     private advanceWake;
     private readonly handleLeave;
-    /**
-     * Answers the preference changing, rather than only its value at setup.
-     *
-     * **The query was created and never listened to**, so the preference was read
-     * at `play` and at the pointer and nowhere else. `tick` books its own next
-     * frame with no check of its own, which means a reader who turned reduce-motion
-     * on while the page was open kept a full-page shader running for the rest of
-     * it: the one reader the promise at the top of this file is about, and the one
-     * it was broken for. The other direction failed the quieter way, a field frozen
-     * on its opening frame until a scroll or a tab switch happened to ask again.
-     *
-     * The still frame is drawn rather than assumed, because the canvas holds
-     * whatever was on it when the loop stopped and mid-drift is not the opening
-     * shape. `Orb` does the same, on the same two arms.
-     */
-    private readonly handleMotion;
-    private readonly handleVisibility;
     private readonly handleScroll;
 }
 declare global {

package/dist/aura/root/aura-root.js

@@ -5,7 +5,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 var HelixAura_1;
-import { customElement, HelixElement, TokenColorController, } from '@fusion.dev/helix-core';
+import { customElement, HelixElement, MAX_FRAME_STEP, PaintGateController, TokenColorController, } from '@fusion.dev/helix-core';
 import { html } from 'lit';
 import { property } from 'lit/decorators.js';
 import { tiltFor } from '../axis.js';
@@ -42,9 +42,7 @@ let HelixAura = class HelixAura extends HelixElement {
         this.program = null;
         this.uniforms = {};
         this.release = 0;
-        this.frame = 0;
         this.elapsed = 0;
-        this.last = 0;
         this.width = 0;
         this.height = 0;
         this.trail = new Float32Array(8 * 3).fill(1);
@@ -53,7 +51,20 @@ let HelixAura = class HelixAura extends HelixElement {
         this.head = { x: 1, y: 1 };
         this.target = { presence: 0, x: 0, y: 0 };
         this.eased = { presence: 0, x: 0, y: 0 };
-        this.onScreen = false;
+        this.gate = new PaintGateController(this, {
+            canRun: () => !!this.gl && !this.gl.isContextLost() && this.width > 0 && this.opened,
+            onFrame: (delta) => {
+                this.advance(delta);
+            },
+            onMotion: (reduced) => {
+                if (reduced) {
+                    this.paintOnce();
+                }
+            },
+            onResize: () => {
+                this.resized();
+            },
+        });
         this.box = { height: 1, left: 0, top: 0, width: 1 };
         this.opened = false;
         this.opening = 0;
@@ -69,7 +80,7 @@ let HelixAura = class HelixAura extends HelixElement {
         };
         this.handleLost = (event) => {
             event.preventDefault();
-            this.stop();
+            this.gate.stop();
             if (this.opening) {
                 cancelAnimationFrame(this.opening);
                 this.opening = 0;
@@ -86,40 +97,15 @@ let HelixAura = class HelixAura extends HelixElement {
             this.measure();
             if (this.opened) {
                 this.paint();
-                this.play();
+                this.gate.play();
             }
             else if (this.width) {
                 this.open();
             }
         };
-        this.tick = (now) => {
-            if (!this.last) {
-                this.last = now;
-            }
-            if (!this.interactive && now - this.last < HelixAura_1.CAPPED) {
-                this.frame = requestAnimationFrame(this.tick);
-                return;
-            }
-            const delta = Math.min((now - this.last) / 1000, 0.05);
-            this.last = now;
-            this.elapsed += delta * Math.max(0, this.drifted(this.speed, 0.4, 0.043));
-            const drift = Math.hypot(this.target.x - this.eased.x, this.target.y - this.eased.y);
-            const follow = 1 - Math.exp(-delta / (0.028 / (1 + drift * 2.4)));
-            if (!this.interactive) {
-                this.target.presence = 0;
-            }
-            this.eased.x += (this.target.x - this.eased.x) * follow;
-            this.eased.y += (this.target.y - this.eased.y) * follow;
-            const rising = this.target.presence > this.eased.presence;
-            const fade = 1 - Math.exp(-delta / (rising ? 0.05 : 0.22));
-            this.eased.presence += (this.target.presence - this.eased.presence) * fade;
-            this.age(delta);
-            this.advanceWake();
-            this.paint();
-            this.frame = requestAnimationFrame(this.tick);
-        };
+        this.held = 0;
         this.handlePointer = (event) => {
-            if (this.motion?.matches) {
+            if (this.gate.reduced) {
                 return;
             }
             const { height, left, top, width } = this.box;
@@ -131,23 +117,6 @@ let HelixAura = class HelixAura extends HelixElement {
         this.handleLeave = () => {
             this.target.presence = 0;
         };
-        this.handleMotion = () => {
-            if (this.motion?.matches) {
-                this.stop();
-                this.paintOnce();
-            }
-            else {
-                this.play();
-            }
-        };
-        this.handleVisibility = () => {
-            if (document.hidden) {
-                this.stop();
-            }
-            else {
-                this.play();
-            }
-        };
         this.handleScroll = () => {
             const rect = this.getBoundingClientRect();
             this.box = { ...this.box, left: rect.left, top: rect.top };
@@ -185,35 +154,10 @@ let HelixAura = class HelixAura extends HelixElement {
         }
         this.canvas?.addEventListener('webglcontextlost', this.handleLost);
         this.canvas?.addEventListener('webglcontextrestored', this.handleRestored);
-        this.motion ??= window.matchMedia('(prefers-reduced-motion: reduce)');
-        this.motion.addEventListener('change', this.handleMotion);
         this.addEventListener('pointermove', this.handlePointer);
         this.addEventListener('pointerleave', this.handleLeave);
-        this.visible = new IntersectionObserver(([entry]) => {
-            this.onScreen = entry?.isIntersecting ?? false;
-            if (this.onScreen) {
-                this.play();
-            }
-            else {
-                this.stop();
-            }
-        });
-        this.visible.observe(this);
-        document.addEventListener('visibilitychange', this.handleVisibility);
+        this.gate.watch();
         window.addEventListener('scroll', this.handleScroll, { capture: true, passive: true });
-        this.sized = new ResizeObserver(() => {
-            if (!this.measure()) {
-                this.paintOnce();
-                return;
-            }
-            if (this.opened) {
-                this.paint();
-                this.play();
-                return;
-            }
-            this.open();
-        });
-        this.sized.observe(this);
         this.readPalette();
         if (this.measure() || (this.width && !this.opened)) {
             this.open();
@@ -307,25 +251,16 @@ let HelixAura = class HelixAura extends HelixElement {
     }
     disconnectedCallback() {
         super.disconnectedCallback();
-        this.stop();
         if (this.opening) {
             cancelAnimationFrame(this.opening);
             this.opening = 0;
             this.openBy = 0;
         }
-        this.visible?.disconnect();
-        this.visible = undefined;
-        this.onScreen = false;
         this.canvas?.removeEventListener('webglcontextlost', this.handleLost);
         this.canvas?.removeEventListener('webglcontextrestored', this.handleRestored);
         this.removeEventListener('pointermove', this.handlePointer);
         this.removeEventListener('pointerleave', this.handleLeave);
-        this.motion?.removeEventListener('change', this.handleMotion);
-        this.motion = undefined;
-        document.removeEventListener('visibilitychange', this.handleVisibility);
         window.removeEventListener('scroll', this.handleScroll, { capture: true });
-        this.sized?.disconnect();
-        this.sized = undefined;
         this.release = window.setTimeout(this.drop, 0);
     }
     readPalette() {
@@ -443,6 +378,18 @@ let HelixAura = class HelixAura extends HelixElement {
         gl.uniform1i(uniforms.uInteraction ?? null, Math.max(0, INTERACTIONS.indexOf(this.interaction ?? 'native')));
         gl.drawArrays(gl.TRIANGLES, 0, 3);
     }
+    resized() {
+        if (!this.measure()) {
+            this.paintOnce();
+            return;
+        }
+        if (this.opened) {
+            this.paint();
+            this.gate.play();
+            return;
+        }
+        this.open();
+    }
     open() {
         if (this.opening) {
             cancelAnimationFrame(this.opening);
@@ -455,7 +402,7 @@ let HelixAura = class HelixAura extends HelixElement {
             this.opening = 0;
             this.opened = true;
             this.paint();
-            this.play();
+            this.gate.play();
         };
         if (performance.now() >= this.openBy) {
             draw();
@@ -464,32 +411,33 @@ let HelixAura = class HelixAura extends HelixElement {
         this.opening = requestAnimationFrame(draw);
     }
     paintOnce() {
-        if (this.frame || !this.opened || !this.isConnected) {
+        if (this.gate.running || !this.opened || !this.isConnected) {
             return;
         }
         this.paint();
     }
-    static { this.CAPPED = 1000 / 30; }
-    play() {
-        if (this.frame ||
-            !this.isConnected ||
-            !this.onScreen ||
-            this.motion?.matches ||
-            document.hidden ||
-            !this.gl ||
-            this.gl.isContextLost() ||
-            !this.width ||
-            !this.opened) {
+    static { this.CAPPED = 1 / 30; }
+    advance(delta) {
+        this.held += delta;
+        if (!this.interactive && this.held < HelixAura_1.CAPPED) {
             return;
         }
-        this.frame = requestAnimationFrame(this.tick);
-    }
-    stop() {
-        if (this.frame) {
-            cancelAnimationFrame(this.frame);
-            this.frame = 0;
+        const step = Math.min(this.held, MAX_FRAME_STEP);
+        this.held = 0;
+        this.elapsed += step * Math.max(0, this.drifted(this.speed, 0.4, 0.043));
+        const drift = Math.hypot(this.target.x - this.eased.x, this.target.y - this.eased.y);
+        const follow = 1 - Math.exp(-step / (0.028 / (1 + drift * 2.4)));
+        if (!this.interactive) {
+            this.target.presence = 0;
         }
-        this.last = 0;
+        this.eased.x += (this.target.x - this.eased.x) * follow;
+        this.eased.y += (this.target.y - this.eased.y) * follow;
+        const rising = this.target.presence > this.eased.presence;
+        const fade = 1 - Math.exp(-step / (rising ? 0.05 : 0.22));
+        this.eased.presence += (this.target.presence - this.eased.presence) * fade;
+        this.age(step);
+        this.advanceWake();
+        this.paint();
     }
     get bearing() {
         if (this.terminus === undefined) {

package/dist/orb/root/orb-root.d.ts

@@ -93,12 +93,16 @@ export declare class HelixOrb extends HelixElement {
     state: OrbState;
     private canvas;
     private context;
-    private motion;
-    private visible;
-    private sized;
-    private frame;
-    private running;
-    private onScreen;
+    /**
+     * Whether anybody is looking, and the loop that draws for them.
+     *
+     * A context it has not been given and one the browser has taken are both
+     * reasons to draw nothing that the gate cannot see, so they are said here.
+     *
+     * Every frame paints: a settled orb has movement of its own in every state,
+     * and only the gate's own three answers stop it.
+     */
+    private readonly gate;
     /** Whether the browser has taken the canvas, as its own two events say. */
     private lost;
     /** The box the canvas was last measured at, in CSS pixels. */
@@ -127,7 +131,6 @@ export declare class HelixOrb extends HelixElement {
      * rate has no such term.
      */
     private phase;
-    private last;
     protected willUpdate(changed: PropertyValues): void;
     protected render(): TemplateResult;
     protected firstUpdated(changed: PropertyValues): void;
@@ -155,10 +158,6 @@ export declare class HelixOrb extends HelixElement {
     /** How far through a transition, `1` when there is not one. */
     private get progress();
     private paramsNow;
-    private play;
-    private stop;
-    private readonly tick;
-    private readonly handleVisibility;
     /**
      * Stops for a canvas the browser has taken, on a GPU reset, until it is
      * given back.
@@ -180,7 +179,6 @@ export declare class HelixOrb extends HelixElement {
      * the top left corner, for as long as the box holds still.
      */
     private readonly handleRestored;
-    private readonly handleMotion;
     /**
      * One frame.
      *

package/dist/orb/root/orb-root.js

@@ -4,7 +4,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { customElement, HelixElement, hostAria, readColor, } from '@fusion.dev/helix-core';
+import { customElement, HelixElement, hostAria, PaintGateController, readColor, } from '@fusion.dev/helix-core';
 import { html } from 'lit';
 import { property } from 'lit/decorators.js';
 import { blendStaged, evenSphere, fibonacci, meshFor, ORB_STATES, orbPoint, paramsFor, project, smoother, stateDistance, TRAIL, } from '../shapes.js';
@@ -29,37 +29,32 @@ let HelixOrb = class HelixOrb extends HelixElement {
         this.label = '';
         this.state = 'thinking';
         this.context = null;
-        this.frame = 0;
-        this.running = false;
-        this.onScreen = false;
+        this.gate = new PaintGateController(this, {
+            canRun: () => !!this.context && !this.lost,
+            onFrame: (delta) => {
+                this.paint(delta);
+            },
+            onMotion: (reduced) => {
+                if (reduced) {
+                    this.phase = STILL_PHASE;
+                    this.morphAt = 0;
+                    this.paint(0);
+                }
+            },
+            onResize: () => {
+                this.measure();
+                this.paint(0);
+            },
+        });
         this.lost = false;
         this.box = 0;
         this.from = paramsFor('thinking');
         this.morphAt = 0;
         this.reach = 0;
         this.phase = STILL_PHASE;
-        this.last = 0;
-        this.tick = () => {
-            if (!this.running) {
-                return;
-            }
-            const now = performance.now();
-            const dt = Math.min(0.05, (now - this.last) / 1000 || 0.016);
-            this.last = now;
-            this.paint(dt);
-            this.frame = requestAnimationFrame(this.tick);
-        };
-        this.handleVisibility = () => {
-            if (document.visibilityState === 'hidden') {
-                this.stop();
-            }
-            else {
-                this.play();
-            }
-        };
         this.handleLost = () => {
             this.lost = true;
-            this.stop();
+            this.gate.stop();
             this.canvas?.toggleAttribute('hidden', true);
         };
         this.handleRestored = () => {
@@ -68,18 +63,7 @@ let HelixOrb = class HelixOrb extends HelixElement {
             this.box = 0;
             this.measure();
             this.paint(0);
-            this.play();
-        };
-        this.handleMotion = () => {
-            if (this.motion?.matches) {
-                this.stop();
-                this.phase = STILL_PHASE;
-                this.morphAt = 0;
-                this.paint(0);
-            }
-            else {
-                this.play();
-            }
+            this.gate.play();
         };
     }
     static { this.styles = styles; }
@@ -112,18 +96,9 @@ let HelixOrb = class HelixOrb extends HelixElement {
     }
     disconnectedCallback() {
         super.disconnectedCallback();
-        this.stop();
-        this.onScreen = false;
         this.box = 0;
         this.canvas?.removeEventListener('contextlost', this.handleLost);
         this.canvas?.removeEventListener('contextrestored', this.handleRestored);
-        this.visible?.disconnect();
-        this.visible = undefined;
-        this.sized?.disconnect();
-        this.sized = undefined;
-        this.motion?.removeEventListener('change', this.handleMotion);
-        this.motion = undefined;
-        document.removeEventListener('visibilitychange', this.handleVisibility);
     }
     start() {
         if (!this.isConnected) {
@@ -144,24 +119,7 @@ let HelixOrb = class HelixOrb extends HelixElement {
             this.lost = false;
             canvas.toggleAttribute('hidden', false);
         }
-        this.motion ??= window.matchMedia('(prefers-reduced-motion: reduce)');
-        this.motion.addEventListener('change', this.handleMotion);
-        this.visible ??= new IntersectionObserver(([entry]) => {
-            this.onScreen = entry?.isIntersecting ?? false;
-            if (this.onScreen && document.visibilityState !== 'hidden') {
-                this.play();
-            }
-            else {
-                this.stop();
-            }
-        });
-        this.visible.observe(this);
-        document.addEventListener('visibilitychange', this.handleVisibility);
-        this.sized ??= new ResizeObserver(() => {
-            this.measure();
-            this.paint(0);
-        });
-        this.sized.observe(this);
+        this.gate.watch();
         this.measure();
         this.paint(0);
     }
@@ -185,9 +143,9 @@ let HelixOrb = class HelixOrb extends HelixElement {
         this.from = this.paramsNow();
         this.reach = stateDistance(this.from, paramsFor(this.state));
         this.morphAt = performance.now();
-        if (!this.running) {
+        if (!this.gate.running) {
             this.paint(0);
-            this.play();
+            this.gate.play();
         }
     }
     get span() {
@@ -204,25 +162,13 @@ let HelixOrb = class HelixOrb extends HelixElement {
         }
         return blendStaged(this.from, to, smoother(k), smoother(Math.max(0, k - TRAIL) / (1 - TRAIL)));
     }
-    play() {
-        if (this.running || this.motion?.matches || !this.onScreen || this.lost) {
-            return;
-        }
-        this.running = true;
-        this.last = performance.now();
-        this.frame = requestAnimationFrame(this.tick);
-    }
-    stop() {
-        this.running = false;
-        cancelAnimationFrame(this.frame);
-    }
     paint(dt) {
         const ctx = this.context;
         const size = this.box;
         if (!ctx || size <= 0) {
             return;
         }
-        const still = this.motion?.matches ?? false;
+        const still = this.gate.reduced;
         const params = still ? paramsFor(this.state) : this.paramsNow();
         this.phase += dt * params.rate;
         const painted = getComputedStyle(ctx.canvas);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fusion.dev/helix",
   "description": "Styled component tier. Extends the headless tier with token-driven presentation.",
-  "version": "0.58.1",
+  "version": "0.59.0",
   "license": "MIT",
   "author": "Ross Sheppard <ross.sheppard@fusion.dev>",
   "repository": {
@@ -47,14 +47,14 @@
   },
   "bugs": "https://github.com/project-fusion/fusion/issues",
   "dependencies": {
-    "@fusion.dev/helix-core": "0.58.1",
-    "@fusion.dev/helix-headless": "0.58.1",
-    "@fusion.dev/helix-styles": "0.58.1"
+    "@fusion.dev/helix-core": "0.59.0",
+    "@fusion.dev/helix-headless": "0.59.0",
+    "@fusion.dev/helix-styles": "0.59.0"
   },
   "devDependencies": {
     "@custom-elements-manifest/analyzer": "^0.11.0",
-    "@fusion.dev/helix-cem": "0.58.1",
-    "@fusion.dev/helix-testing": "0.58.1",
+    "@fusion.dev/helix-cem": "0.59.0",
+    "@fusion.dev/helix-testing": "0.59.0",
     "@fusion.dev/scripts": "0.0.0-dev",
     "@happy-dom/global-registrator": "^20.0.0",
     "@lit-labs/ssr": "^4.1.0",